@harness-engineering/orchestrator 0.13.0 → 0.15.0

package/dist/index.js

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   AdaptiveRouter: () => AdaptiveRouter,
   AnalysisArchive: () => AnalysisArchive,
+  BRAINSTORM_RUBRIC: () => BRAINSTORM_RUBRIC,
   BUILT_IN_TASKS: () => BUILT_IN_TASKS,
   BackendDefSchema: () => BackendDefSchema,
   BackendRouter: () => BackendRouter,
@@ -74,8 +75,10 @@ __export(index_exports, {
   WorkspaceManager: () => WorkspaceManager,
   applyEvent: () => applyEvent,
   artifactPresenceFromIssue: () => artifactPresenceFromIssue,
+  brainstormInputFromIssue: () => brainstormInputFromIssue,
   buildArchiveHooks: () => buildArchiveHooks,
   buildCapabilityRegistry: () => buildCapabilityRegistry,
+  buildProbeInput: () => buildProbeInput,
   buildWorkflowContext: () => buildWorkflowContext,
   calculateRetryDelay: () => calculateRetryDelay,
   canDispatch: () => canDispatch,
@@ -95,6 +98,7 @@ __export(index_exports, {
   emitProposalApproved: () => emitProposalApproved,
   emitProposalCreated: () => emitProposalCreated,
   emitProposalRejected: () => emitProposalRejected,
+  enrichIssueWithSpec: () => enrichIssueWithSpec,
   estimateCost: () => estimateCost,
   explicitFindingsCount: () => explicitFindingsCount,
   extractHighlights: () => extractHighlights,
@@ -109,22 +113,30 @@ __export(index_exports, {
   launchTUI: () => launchTUI,
   loadPublishedIndex: () => loadPublishedIndex,
   makeBackendResolver: () => makeBackendResolver,
+  makeGraphScope: () => makeGraphScope,
+  makeSelForkGenerator: () => makeSelForkGenerator,
+  markApprovedForDispatch: () => markApprovedForDispatch,
   migrateAgentConfig: () => migrateAgentConfig,
   normalizeFts5Query: () => normalizeFts5Query,
   normalizeHarnessCommand: () => normalizeHarnessCommand,
   normalizeLocalModel: () => normalizeLocalModel,
   openSearchIndex: () => openSearchIndex,
+  pilotScore: () => import_intelligence13.pilotScore,
+  precedentLookupFromStored: () => precedentLookupFromStored,
   promote: () => promote,
+  rankTriageCandidates: () => import_intelligence13.rankTriageCandidates,
   reconcile: () => reconcile,
   recoverFindingsCount: () => recoverFindingsCount,
   reindexFromArchive: () => reindexFromArchive,
   renderAnalysisComment: () => renderAnalysisComment,
   renderLlmSummaryMarkdown: () => renderLlmSummaryMarkdown,
   renderPRComment: () => renderPRComment,
+  renderSpecMarkdown: () => renderSpecMarkdown,
   resolveEscalationConfig: () => resolveEscalationConfig,
   resolveOrchestratorId: () => resolveOrchestratorId,
   routeIssue: () => routeIssue,
   routingWarnings: () => routingWarnings,
+  runBrainstormForIssue: () => runBrainstormForIssue,
   runGate: () => runGate,
   runHarnessCheck: () => runHarnessCheck,
   savePublishedIndex: () => savePublishedIndex,
@@ -132,10 +144,11 @@ __export(index_exports, {
   selectCandidates: () => selectCandidates,
   selectCheapestQualifying: () => selectCheapestQualifying,
   selectTasks: () => selectTasks,
+  slugFor: () => slugFor,
   sortCandidates: () => sortCandidates,
   summarizeArchivedSession: () => summarizeArchivedSession,
   syncMain: () => syncMain,
-  triageIssue: () => triageIssue,
+  triageIssue: () => triageIssue2,
   truncateForBudget: () => truncateForBudget,
   validateCustomTasks: () => validateCustomTasks,
   validateWorkflowConfig: () => validateWorkflowConfig,
@@ -2054,26 +2067,60 @@ var ModelSchema = import_zod.z.union([import_zod.z.string().min(1), import_zod.z
     message: "model must be a non-empty string or array of strings"
   })
 });
+var CAPABILITY_TIER = import_zod.z.enum(["fast", "standard", "strong"]);
+var COMPLEXITY_LEVEL = import_zod.z.enum(["trivial", "simple", "moderate", "complex"]);
+var PRIVACY_CLASS = import_zod.z.enum(["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]);
+var BackendCapabilitiesSchema = import_zod.z.object({
+  tier: CAPABILITY_TIER,
+  costPer1kTokens: import_zod.z.number().nonnegative(),
+  privacyClass: PRIVACY_CLASS,
+  contextWindow: import_zod.z.number().int().positive(),
+  vision: import_zod.z.boolean().optional(),
+  toolUse: import_zod.z.boolean().optional()
+}).strict();
+var RoutingPolicySchema = import_zod.z.object({
+  complexityTierMatrix: import_zod.z.record(COMPLEXITY_LEVEL, CAPABILITY_TIER).optional(),
+  skillTierOverrides: import_zod.z.record(import_zod.z.string(), CAPABILITY_TIER).optional(),
+  privacyFloor: PRIVACY_CLASS.optional(),
+  budget: import_zod.z.object({
+    capUsd: import_zod.z.number(),
+    degradeAtPct: import_zod.z.number().optional(),
+    onBudgetExhausted: import_zod.z.enum(["degrade", "pause", "human"])
+  }).optional(),
+  sensitivePaths: import_zod.z.array(import_zod.z.string()).optional(),
+  escalationThreshold: import_zod.z.number().optional(),
+  // string[], NOT the finite BackendDef['type'] union: an unknown provider must
+  // fail CLOSED at tier selection, not reject the whole policy (Shuttle wire).
+  allowedProviders: import_zod.z.array(import_zod.z.string()).optional(),
+  acceptanceEval: import_zod.z.object({
+    enabled: import_zod.z.boolean(),
+    model: import_zod.z.string().optional()
+  }).optional()
+});
 var BackendDefSchema = import_zod.z.discriminatedUnion("type", [
-  import_zod.z.object({ type: import_zod.z.literal("mock") }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("mock"), capabilities: BackendCapabilitiesSchema.optional() }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("claude"),
-    command: import_zod.z.string().optional()
+    command: import_zod.z.string().optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("anthropic"),
     model: import_zod.z.string().min(1),
-    apiKey: import_zod.z.string().optional()
+    apiKey: import_zod.z.string().optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("openai"),
     model: import_zod.z.string().min(1),
-    apiKey: import_zod.z.string().optional()
+    apiKey: import_zod.z.string().optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("gemini"),
     model: import_zod.z.string().min(1),
-    apiKey: import_zod.z.string().optional()
+    apiKey: import_zod.z.string().optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("local"),
@@ -2081,7 +2128,8 @@ var BackendDefSchema = import_zod.z.discriminatedUnion("type", [
     model: ModelSchema,
     apiKey: import_zod.z.string().optional(),
     timeoutMs: import_zod.z.number().int().positive().optional(),
-    probeIntervalMs: import_zod.z.number().int().min(1e3).optional()
+    probeIntervalMs: import_zod.z.number().int().min(1e3).optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict(),
   import_zod.z.object({
     type: import_zod.z.literal("pi"),
@@ -2089,7 +2137,8 @@ var BackendDefSchema = import_zod.z.discriminatedUnion("type", [
     model: ModelSchema,
     apiKey: import_zod.z.string().optional(),
     timeoutMs: import_zod.z.number().int().positive().optional(),
-    probeIntervalMs: import_zod.z.number().int().min(1e3).optional()
+    probeIntervalMs: import_zod.z.number().int().min(1e3).optional(),
+    capabilities: BackendCapabilitiesSchema.optional()
   }).strict()
 ]);
 var RoutingValueSchema = import_zod.z.union([
@@ -2114,7 +2163,36 @@ var RoutingConfigSchema = import_zod.z.object({
   }).strict().optional(),
   // --- Spec B Phase 0: new optional maps (resolver wired in Phase 1) ---
   skills: import_zod.z.record(import_zod.z.string().min(1), RoutingValueSchema).optional(),
-  modes: import_zod.z.record(import_zod.z.string().min(1), RoutingValueSchema).optional()
+  modes: import_zod.z.record(import_zod.z.string().min(1), RoutingValueSchema).optional(),
+  // --- AMR: opt-in adaptive-routing policy. Its PRESENCE flips the orchestrator
+  // from identity/default dispatch to complexity-aware tier routing (default-off
+  // when absent). Previously accepted by the runtime PUT endpoint only. ---
+  policy: RoutingPolicySchema.optional()
+}).strict();
+var CONFIDENCE = import_zod.z.enum(["low", "medium", "high"]);
+var V1_MAX_RATCHET_STAGE = 2;
+var RATCHET_STAGE = import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(2), import_zod.z.literal(3), import_zod.z.literal(4)]).refine((s) => s <= V1_MAX_RATCHET_STAGE, {
+  message: `ratchetStage ${">"} ${V1_MAX_RATCHET_STAGE} is deferred post-v1 (stages 3\u20134 not yet supported); use 1 or 2`
+});
+var RoadmapAutoTriageSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean(),
+  schedule: import_zod.z.string().min(1).optional(),
+  ratchetStage: RATCHET_STAGE,
+  thresholds: import_zod.z.object({
+    dispatchConfidence: CONFIDENCE,
+    boundedScopeMax: import_zod.z.number(),
+    brainstormConfidence: import_zod.z.number(),
+    exceededByBands: import_zod.z.number(),
+    ratchetAdvanceRate: import_zod.z.number(),
+    ratchetMinSample: import_zod.z.number()
+  }).strict(),
+  depthBudget: import_zod.z.object({
+    trivial: import_zod.z.number(),
+    simple: import_zod.z.number()
+  }).strict()
+}).strict();
+var RoadmapConfigSchema = import_zod.z.object({
+  autoTriage: RoadmapAutoTriageSchema.optional()
 }).strict();
 var WorkflowStepSchema = import_zod.z.object({
   skill: import_zod.z.string().min(1),
@@ -2153,12 +2231,12 @@ var BackendsMapSchema = import_zod2.z.record(import_zod2.z.string(), BackendDefS
 function crossFieldRoutingIssues(backends, routing) {
   const issues = [];
   const names = new Set(Object.keys(backends));
-  const checkRef = (path24, value) => {
+  const checkRef = (path25, value) => {
     if (value === void 0) return;
     const entries = Array.isArray(value) ? value : [value];
     entries.forEach((name, idx) => {
       if (names.has(name)) return;
-      const pathWithIdx = Array.isArray(value) ? [...path24, String(idx)] : path24;
+      const pathWithIdx = Array.isArray(value) ? [...path25, String(idx)] : path25;
       issues.push({
         path: pathWithIdx,
         message: `routing.${pathWithIdx.join(".")} references unknown backend '${name}'. Defined: [${[...names].join(", ")}].`
@@ -2255,6 +2333,10 @@ function validateWorkflowConfig(config, options = {}) {
     const parsed = import_zod2.z.array(StagedWorkflowDeclSchema).safeParse(c.workflows);
     if (!parsed.success) return (0, import_types2.Err)(new Error(`workflows: ${parsed.error.message}`));
   }
+  if (c.roadmap !== void 0) {
+    const parsed = RoadmapConfigSchema.safeParse(c.roadmap);
+    if (!parsed.success) return (0, import_types2.Err)(new Error(`roadmap: ${parsed.error.message}`));
+  }
   return (0, import_types2.Ok)({ config, warnings });
 }
 function getDefaultConfig() {
@@ -3497,7 +3579,65 @@ var path21 = __toESM(require("path"));
 var import_node_crypto15 = require("crypto");
 var import_types34 = require("@harness-engineering/types");
 var import_core16 = require("@harness-engineering/core");
-var import_intelligence11 = require("@harness-engineering/intelligence");
+var import_intelligence12 = require("@harness-engineering/intelligence");
+
+// src/agent/triage-outcome.ts
+var import_intelligence = require("@harness-engineering/intelligence");
+function signalsFromDiff(hunks, textOnly) {
+  const files = /* @__PURE__ */ new Set();
+  const layers = /* @__PURE__ */ new Set();
+  let addedLines = 0;
+  for (const h of hunks) {
+    files.add(h.file);
+    layers.add(layerOfPath(h.file));
+    addedLines += h.addedContent === "" ? 0 : h.addedContent.split("\n").length;
+  }
+  return {
+    ...textOnly,
+    filesTouched: files.size,
+    layersTouched: layers.size,
+    blastRadius: addedLines
+  };
+}
+function layerOfPath(file) {
+  const parts = file.split("/").filter((p) => p.length > 0);
+  if (parts.length === 0) return "<root>";
+  if (parts[0] === "packages" && parts.length >= 4 && parts[2] === "src") {
+    return `${parts[1] ?? ""}/${parts[3] ?? ""}`;
+  }
+  return parts.length === 1 ? "<root>" : parts[0] ?? "<root>";
+}
+async function runRetrospective(deps, provider) {
+  const signals = signalsFromDiff(deps.hunks, deps.textOnly);
+  const actual = await (0, import_intelligence.classify)(
+    { signals, phase: "post-diff", riskHigh: deps.riskHigh, prompt: deps.prompt },
+    provider
+  );
+  const comparison = deps.comparatorConfig ? (0, import_intelligence.compareToPrediction)(deps.prediction, actual, deps.comparatorConfig) : (0, import_intelligence.compareToPrediction)(deps.prediction, actual);
+  return { actual, comparison };
+}
+function buildTriageOutcomeInput(externalId, shapeKey, result) {
+  return {
+    externalId,
+    shapeKey,
+    actual: result.actual,
+    exceededBy: result.comparison.exceededBy,
+    matched: result.comparison.matched
+  };
+}
+function precedentLookupFromStored(records) {
+  const bridged = records.map((r) => ({
+    externalId: "",
+    shapeKey: r.shapeKey,
+    ts: "",
+    ...r.outcome ? { outcome: { actual: void 0, exceededBy: 0, matched: r.outcome.matched } } : {}
+  }));
+  return {
+    rateForShape: (shapeKey) => (0, import_intelligence.aggregatePrecedent)(bridged, shapeKey)
+  };
+}
+
+// src/orchestrator.ts
 var import_graph2 = require("@harness-engineering/graph");
 
 // src/core/stall-detector.ts
@@ -3518,7 +3658,7 @@ function detectStalledIssues(running, nowMs, stallTimeoutMs) {
 
 // src/intelligence/pipeline-runner.ts
 var path9 = __toESM(require("path"));
-var import_intelligence = require("@harness-engineering/intelligence");
+var import_intelligence2 = require("@harness-engineering/intelligence");
 var import_core2 = require("@harness-engineering/core");
 var CONNECTION_ERROR_PATTERNS = [
   "Connection error",
@@ -3623,7 +3763,7 @@ var IntelligencePipelineRunner = class {
   refreshSpecializationProfiles() {
     if (!this.ctx.graphStore) return;
     try {
-      const store = (0, import_intelligence.refreshProfiles)(this.ctx.projectRoot, this.ctx.graphStore);
+      const store = (0, import_intelligence2.refreshProfiles)(this.ctx.projectRoot, this.ctx.graphStore);
       const personaCount = Object.keys(store.profiles).length;
       if (personaCount > 0) {
         this.ctx.logger.info(`Refreshed specialization profiles for ${personaCount} persona(s)`);
@@ -3866,7 +4006,7 @@ var IntelligencePipelineRunner = class {
       for (const issue of candidates) {
         const systemNodeIds = issue.labels.filter((l) => l.startsWith("system:") || l.startsWith("module:")).map((l) => l.split(":")[1]).filter((id) => id.length > 0);
         if (systemNodeIds.length === 0) continue;
-        const recs = (0, import_intelligence.weightedRecommendPersona)(this.ctx.graphStore, { systemNodeIds });
+        const recs = (0, import_intelligence2.weightedRecommendPersona)(this.ctx.graphStore, { systemNodeIds });
         if (recs.length > 0) {
           results.set(issue.id, recs);
         }
@@ -4775,11 +4915,11 @@ function detectLegacyFields(agent) {
 }
 function buildCase1Warnings(presentLegacy, suppressLocalGroup) {
   const warnings = [];
-  for (const path24 of presentLegacy) {
-    if (CASE1_ALWAYS_SUPPRESS.has(path24)) continue;
-    if (suppressLocalGroup && CASE1_LOCAL_GROUP.has(path24)) continue;
+  for (const path25 of presentLegacy) {
+    if (CASE1_ALWAYS_SUPPRESS.has(path25)) continue;
+    if (suppressLocalGroup && CASE1_LOCAL_GROUP.has(path25)) continue;
     warnings.push(
-      `Ignoring legacy field '${path24}': 'agent.backends' is set and takes precedence. See ${MIGRATION_GUIDE}.`
+      `Ignoring legacy field '${path25}': 'agent.backends' is set and takes precedence. See ${MIGRATION_GUIDE}.`
     );
   }
   return warnings;
@@ -4807,7 +4947,7 @@ function migrateAgentConfig(agent) {
   }
   const { backends, routing } = synthesizeBackendsAndRouting(agent);
   const warnings = presentLegacy.map(
-    (path24) => `Deprecated config field '${path24}' is in use. Migrate to 'agent.backends' / 'agent.routing'. See ${MIGRATION_GUIDE}.`
+    (path25) => `Deprecated config field '${path25}' is in use. Migrate to 'agent.backends' / 'agent.routing'. See ${MIGRATION_GUIDE}.`
   );
   return {
     config: { ...agent, backends, routing },
@@ -4892,12 +5032,12 @@ var BackendRouter = class {
    */
   resolve(useCase, opts) {
     const startedAt = performance.now();
-    const path24 = [];
+    const path25 = [];
     const tryChain = (source, value) => {
       if (value === void 0) return void 0;
       for (const name of toArray(value)) {
         const step = { source, candidate: name, outcome: "considered" };
-        path24.push(step);
+        path25.push(step);
         if (this.backends[name]) {
           step.outcome = "chosen";
           return name;
@@ -4916,7 +5056,7 @@ var BackendRouter = class {
       return {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         useCase,
-        resolutionPath: path24,
+        resolutionPath: path25,
         backendName,
         backendType: def.type,
         durationMs: performance.now() - startedAt
@@ -4949,7 +5089,7 @@ var BackendRouter = class {
     if (fromDefault) return emitAndReturn(decide(fromDefault));
     const knownList = Object.keys(this.backends).join(", ") || "(none)";
     throw new Error(
-      `BackendRouter.resolve: routing.default produced no available backend for useCase=${JSON.stringify(useCase)}. Resolution path: ${JSON.stringify(path24)}. Known backends: [${knownList}].`
+      `BackendRouter.resolve: routing.default produced no available backend for useCase=${JSON.stringify(useCase)}. Resolution path: ${JSON.stringify(path25)}. Known backends: [${knownList}].`
     );
   }
   /**
@@ -5042,7 +5182,7 @@ var BackendRouter = class {
       check(`modes.${mode}`, value);
     }
     if (missing.length > 0) {
-      const detail = missing.map(({ path: path24, name }) => `routing.${path24} -> '${name}'`).join("; ");
+      const detail = missing.map(({ path: path25, name }) => `routing.${path25} -> '${name}'`).join("; ");
       const known_ = [...known].join(", ") || "(none)";
       throw new Error(
         `BackendRouter: routing references unknown backend(s): ${detail}. Defined backends: [${known_}].`
@@ -7435,11 +7575,11 @@ function createAgentDispatcher(deps) {
 var import_node_child_process13 = require("child_process");
 
 // src/agent/intelligence-factory.ts
-var import_intelligence3 = require("@harness-engineering/intelligence");
+var import_intelligence4 = require("@harness-engineering/intelligence");
 var import_graph = require("@harness-engineering/graph");
 
 // src/agent/analysis-provider-factory.ts
-var import_intelligence2 = require("@harness-engineering/intelligence");
+var import_intelligence3 = require("@harness-engineering/intelligence");
 function buildAnalysisProvider(args) {
   const { def, backendName, layer, intelligence, logger } = args;
   const layerModel = layer === "sel" ? intelligence?.models?.sel : intelligence?.models?.pesl;
@@ -7479,7 +7619,7 @@ function buildLocalLikeProvider(def, args, layerModel) {
   logger.info(
     `Intelligence pipeline using backend '${backendName}' (${def.type}) at ${def.endpoint} (model: ${model ?? "(default)"})`
   );
-  return new import_intelligence2.OpenAICompatibleAnalysisProvider({
+  return new import_intelligence3.OpenAICompatibleAnalysisProvider({
     apiKey,
     baseUrl: def.endpoint,
     ...model !== void 0 && { defaultModel: model },
@@ -7497,7 +7637,7 @@ function buildAnthropicProvider(def, args, layerModel) {
   const apiKey = def.apiKey ?? process.env.ANTHROPIC_API_KEY;
   const model = layerModel ?? def.model;
   if (apiKey) {
-    return new import_intelligence2.AnthropicAnalysisProvider({
+    return new import_intelligence3.AnthropicAnalysisProvider({
       apiKey,
       ...model !== void 0 && { defaultModel: model }
     });
@@ -7505,7 +7645,7 @@ function buildAnthropicProvider(def, args, layerModel) {
   args.logger.info(
     `Intelligence pipeline routed to '${args.backendName}' (anthropic) without API key \u2014 using Claude CLI fallback.`
   );
-  return new import_intelligence2.ClaudeCliAnalysisProvider({
+  return new import_intelligence3.ClaudeCliAnalysisProvider({
     ...model !== void 0 && { defaultModel: model },
     ...args.intelligence?.requestTimeoutMs !== void 0 && {
       timeoutMs: args.intelligence.requestTimeoutMs
@@ -7521,7 +7661,7 @@ function buildOpenAIProvider(def, args, layerModel) {
     return null;
   }
   const model = layerModel ?? def.model;
-  return new import_intelligence2.OpenAICompatibleAnalysisProvider({
+  return new import_intelligence3.OpenAICompatibleAnalysisProvider({
     apiKey,
     baseUrl: "https://api.openai.com/v1",
     ...model !== void 0 && { defaultModel: model },
@@ -7531,7 +7671,7 @@ function buildOpenAIProvider(def, args, layerModel) {
   });
 }
 function buildClaudeCliProvider(def, args, layerModel) {
-  return new import_intelligence2.ClaudeCliAnalysisProvider({
+  return new import_intelligence3.ClaudeCliAnalysisProvider({
     ...def.command !== void 0 && { command: def.command },
     ...layerModel !== void 0 && { defaultModel: layerModel },
     ...args.intelligence?.requestTimeoutMs !== void 0 && {
@@ -7552,7 +7692,7 @@ function buildIntelligencePipeline(deps) {
   const peslProvider = peslName !== selName ? buildAnalysisProviderForLayer("pesl", deps) : null;
   const peslModel = intel.models?.pesl ?? config.agent.model;
   const graphStore = new import_graph.GraphStore();
-  const pipeline = new import_intelligence3.IntelligencePipeline(selProvider, graphStore, {
+  const pipeline = new import_intelligence4.IntelligencePipeline(selProvider, graphStore, {
     ...peslModel !== void 0 && { peslModel },
     ...peslProvider !== null && peslProvider !== void 0 && { peslProvider }
   });
@@ -7618,13 +7758,13 @@ function buildExplicitProvider(provider, selModel, config) {
     if (!apiKey2) {
       throw new Error("Intelligence pipeline: no Anthropic API key found.");
     }
-    return new import_intelligence3.AnthropicAnalysisProvider({
+    return new import_intelligence4.AnthropicAnalysisProvider({
       apiKey: apiKey2,
       ...selModel !== void 0 && { defaultModel: selModel }
     });
   }
   if (provider.kind === "claude-cli") {
-    return new import_intelligence3.ClaudeCliAnalysisProvider({
+    return new import_intelligence4.ClaudeCliAnalysisProvider({
       command: config.agent.command,
       ...selModel !== void 0 && { defaultModel: selModel },
       ...config.intelligence?.requestTimeoutMs !== void 0 && {
@@ -7635,7 +7775,7 @@ function buildExplicitProvider(provider, selModel, config) {
   const apiKey = provider.apiKey ?? config.agent.apiKey ?? "ollama";
   const baseUrl = provider.baseUrl ?? "http://localhost:11434/v1";
   const intel = config.intelligence;
-  return new import_intelligence3.OpenAICompatibleAnalysisProvider({
+  return new import_intelligence4.OpenAICompatibleAnalysisProvider({
     apiKey,
     baseUrl,
     ...selModel !== void 0 && { defaultModel: selModel },
@@ -7646,13 +7786,13 @@ function buildExplicitProvider(provider, selModel, config) {
 }
 
 // src/agent/adaptive-router.ts
-var import_intelligence6 = require("@harness-engineering/intelligence");
+var import_intelligence7 = require("@harness-engineering/intelligence");
 var import_types24 = require("@harness-engineering/types");
 
 // src/agent/capability-registry.ts
 var import_types23 = require("@harness-engineering/types");
 var import_local_models2 = require("@harness-engineering/local-models");
-var import_intelligence4 = require("@harness-engineering/intelligence");
+var import_intelligence5 = require("@harness-engineering/intelligence");
 var PrivacyNoMatch = class extends import_types23.RoutingError {
   code = "privacy-no-match";
   constructor(message) {
@@ -7667,7 +7807,7 @@ var PRIVACY_RANK = {
   "shared-cloud": 3
 };
 function selectCheapestQualifying(registry, requiredTier, constraints, providerOf) {
-  const requiredRank = import_intelligence4.TIER_RANK[requiredTier];
+  const requiredRank = import_intelligence5.TIER_RANK[requiredTier];
   const entries = [...registry.entries()].map(([name, capabilities]) => ({
     name,
     capabilities
@@ -7689,7 +7829,7 @@ function selectCheapestQualifying(registry, requiredTier, constraints, providerO
   }
   const qualifying = passesPrivacyAllow.filter((e) => {
     const c = e.capabilities;
-    if (import_intelligence4.TIER_RANK[c.tier] < requiredRank) return false;
+    if (import_intelligence5.TIER_RANK[c.tier] < requiredRank) return false;
     if (constraints.needsVision && !c.vision) return false;
     if (constraints.needsToolUse && !c.toolUse) return false;
     if (constraints.minContextTokens !== void 0 && c.contextWindow < constraints.minContextTokens)
@@ -7728,7 +7868,7 @@ function estimateCost(def, _req) {
 }
 
 // src/agent/escalation-state.ts
-var import_intelligence5 = require("@harness-engineering/intelligence");
+var import_intelligence6 = require("@harness-engineering/intelligence");
 var EscalationState = class {
   constructor(threshold = 2) {
     this.threshold = threshold;
@@ -7757,7 +7897,7 @@ var EscalationState = class {
   climbedUnits() {
     const out = [];
     for (const [coherenceUnit, state] of this.units) {
-      if (import_intelligence5.TIER_RANK[state.floorTier] > import_intelligence5.TIER_RANK.fast) {
+      if (import_intelligence6.TIER_RANK[state.floorTier] > import_intelligence6.TIER_RANK.fast) {
         out.push({ coherenceUnit, floor: state.floorTier });
       }
     }
@@ -7796,14 +7936,14 @@ var EscalationState = class {
       return "ok";
     }
     state.failures = 0;
-    const currentRank = import_intelligence5.TIER_RANK[state.floorTier];
-    if (currentRank >= import_intelligence5.TIER_RANK.strong) {
+    const currentRank = import_intelligence6.TIER_RANK[state.floorTier];
+    if (currentRank >= import_intelligence6.TIER_RANK.strong) {
       state.floorTier = "strong";
       state.escalated = true;
       this.units.set(coherenceUnit, state);
       return "exhausted";
     }
-    state.floorTier = import_intelligence5.RANK_TIER[currentRank + 1];
+    state.floorTier = import_intelligence6.RANK_TIER[currentRank + 1];
     state.escalated = true;
     this.units.set(coherenceUnit, state);
     return "escalated";
@@ -7939,7 +8079,7 @@ var AdaptiveRouter = class _AdaptiveRouter {
     let budgetStatus = null;
     if (budget && budget.capUsd > 0) {
       const spentUsd = this.getSpentUsd();
-      const degradeAtPct = budget.degradeAtPct ?? import_intelligence6.DEFAULT_DEGRADE_AT_PCT;
+      const degradeAtPct = budget.degradeAtPct ?? import_intelligence7.DEFAULT_DEGRADE_AT_PCT;
       budgetStatus = {
         spentUsd,
         capUsd: budget.capUsd,
@@ -7971,8 +8111,8 @@ var AdaptiveRouter = class _AdaptiveRouter {
       );
     }
     const unitFloor = this.deps.escalation?.floorFor(req.coherenceUnit) ?? "fast";
-    const escalationFloor = import_intelligence6.RANK_TIER[Math.max(import_intelligence6.TIER_RANK[unitFloor], import_intelligence6.TIER_RANK[req.floor ?? "fast"])];
-    const requiredTier = (0, import_intelligence6.deriveRequiredTier)(
+    const escalationFloor = import_intelligence7.RANK_TIER[Math.max(import_intelligence7.TIER_RANK[unitFloor], import_intelligence7.TIER_RANK[req.floor ?? "fast"])];
+    const requiredTier = (0, import_intelligence7.deriveRequiredTier)(
       complexity,
       req.risk,
       this.deps.policy,
@@ -8129,10 +8269,10 @@ var RoutingDecisionBus = class {
 };
 
 // src/workflow/execute-workflow.ts
-var import_intelligence7 = require("@harness-engineering/intelligence");
+var import_intelligence8 = require("@harness-engineering/intelligence");
 function nextTier(t) {
-  const next = Math.min(import_intelligence7.TIER_RANK[t] + 1, import_intelligence7.TIER_RANK.strong);
-  return import_intelligence7.RANK_TIER[next];
+  const next = Math.min(import_intelligence8.TIER_RANK[t] + 1, import_intelligence8.TIER_RANK.strong);
+  return import_intelligence8.RANK_TIER[next];
 }
 var DEFAULT_STAGE_DEADLINE_MS = 12e4;
 function stageAttemptKey(stageIndex, attempt) {
@@ -8354,7 +8494,7 @@ function buildRoutingUseCase(issue, backendParam, catalog) {
 }
 
 // src/agent/live-classify.ts
-var import_intelligence8 = require("@harness-engineering/intelligence");
+var import_intelligence9 = require("@harness-engineering/intelligence");
 var CONSERVATIVE = {
   level: "moderate",
   confidence: "low",
@@ -8377,7 +8517,7 @@ function makeLiveClassify(resolveProvider) {
       riskHigh,
       prompt: taskText.prompt
     };
-    return (0, import_intelligence8.classify)(input, resolveProvider());
+    return (0, import_intelligence9.classify)(input, resolveProvider());
   };
 }
 
@@ -8900,7 +9040,7 @@ function extractChunks(event) {
 }
 
 // src/server/routes/analyze.ts
-var import_intelligence9 = require("@harness-engineering/intelligence");
+var import_intelligence10 = require("@harness-engineering/intelligence");
 var import_zod7 = require("zod");
 var AnalyzeRequestSchema = import_zod7.z.object({
   title: import_zod7.z.string().min(1),
@@ -8930,7 +9070,7 @@ async function runPipeline(res, pipeline, parsed) {
     disconnected = true;
   });
   emit2(res, { type: "status", text: "Converting to work item..." });
-  const rawItem = (0, import_intelligence9.manualToRawWorkItem)({
+  const rawItem = (0, import_intelligence10.manualToRawWorkItem)({
     title: parsed.title,
     description: parsed.description ?? "",
     labels: parsed.labels ?? []
@@ -8973,7 +9113,7 @@ async function runPipeline(res, pipeline, parsed) {
     }
   }
   if (disconnected) return;
-  const signals = (0, import_intelligence9.scoreToConcernSignals)(score);
+  const signals = (0, import_intelligence10.scoreToConcernSignals)(score);
   if (signals.length > 0) {
     emit2(res, { type: "signals", data: signals });
   }
@@ -10633,7 +10773,7 @@ function handleV1LocalModelsMutationRoute(req, res, deps) {
 
 // src/server/routes/v1/routing.ts
 var import_zod14 = require("zod");
-var import_intelligence10 = require("@harness-engineering/intelligence");
+var import_intelligence11 = require("@harness-engineering/intelligence");
 var CONFIG_RE = /^\/api\/v1\/routing\/config(?:\?.*)?$/;
 var DECISIONS_RE = /^\/api\/v1\/routing\/decisions(?:\?.*)?$/;
 var TRACE_RE = /^\/api\/v1\/routing\/trace(?:\?.*)?$/;
@@ -10737,7 +10877,7 @@ function deriveTraceCost(body, decision, def, routing, backends) {
     source: "static"
   };
   const risk = body.risk === "high" ? { blastRadius: 10, sensitivePath: true } : { blastRadius: 0, sensitivePath: false };
-  const tierRequired = (0, import_intelligence10.deriveRequiredTier)(
+  const tierRequired = (0, import_intelligence11.deriveRequiredTier)(
     verdict,
     risk,
     routing.policy ?? {},
@@ -10752,7 +10892,12 @@ function deriveTraceCost(body, decision, def, routing, backends) {
     backends
   );
   const estCostUsd = estimateCost(costedDef, { useCase: body.useCase });
-  return { tierRequired, estCostUsd, costedBackendName: costedName };
+  return {
+    tierRequired,
+    estCostUsd,
+    costedBackendName: costedName,
+    costedBackendType: costedDef.type
+  };
 }
 function selectCostedBackend(tierRequired, decision, def, routing, backends) {
   const registry = buildCapabilityRegistry(backends);
@@ -10817,7 +10962,7 @@ async function handleTrace(req, res, deps) {
       opts
     );
     if (r.data.complexity !== void 0 || r.data.risk !== void 0) {
-      const { tierRequired, estCostUsd, costedBackendName } = deriveTraceCost(
+      const { tierRequired, estCostUsd, costedBackendName, costedBackendType } = deriveTraceCost(
         r.data,
         decision,
         def,
@@ -10829,9 +10974,12 @@ async function handleTrace(req, res, deps) {
         def: { type: def.type },
         tierRequired,
         estCostUsd,
-        // Name the backend the cost belongs to so operators see tier↔cost↔backend
-        // are consistent (was implicit + divergent before this fix).
-        costedBackendName
+        // The backend AMR would ACTUALLY dispatch to at this tier (cheapest
+        // qualifying) + its type — distinct from the identity-chain `decision`
+        // above. The CLI shows this as the effective backend so tier↔cost↔backend
+        // read consistently (was implicit + divergent before).
+        costedBackendName,
+        costedBackendType
       });
       return true;
     }
@@ -10841,26 +10989,6 @@ async function handleTrace(req, res, deps) {
   }
   return true;
 }
-var CAPABILITY_TIER = import_zod14.z.enum(["fast", "standard", "strong"]);
-var COMPLEXITY_LEVEL = import_zod14.z.enum(["trivial", "simple", "moderate", "complex"]);
-var PRIVACY_CLASS = import_zod14.z.enum(["on-device", "byo-endpoint", "shared-cloud"]);
-var RoutingPolicySchema = import_zod14.z.object({
-  complexityTierMatrix: import_zod14.z.record(COMPLEXITY_LEVEL, CAPABILITY_TIER).optional(),
-  skillTierOverrides: import_zod14.z.record(import_zod14.z.string(), CAPABILITY_TIER).optional(),
-  privacyFloor: PRIVACY_CLASS.optional(),
-  budget: import_zod14.z.object({
-    capUsd: import_zod14.z.number(),
-    degradeAtPct: import_zod14.z.number().optional(),
-    onBudgetExhausted: import_zod14.z.enum(["degrade", "pause", "human"])
-  }).optional(),
-  sensitivePaths: import_zod14.z.array(import_zod14.z.string()).optional(),
-  escalationThreshold: import_zod14.z.number().optional(),
-  allowedProviders: import_zod14.z.array(import_zod14.z.string()).optional(),
-  acceptanceEval: import_zod14.z.object({
-    enabled: import_zod14.z.boolean(),
-    model: import_zod14.z.string().optional()
-  }).optional()
-});
 async function handlePolicy(req, res, deps) {
   if (!deps.ingestRoutingPolicy || deps.router === null) return unavailable(res);
   let raw;
@@ -11406,8 +11534,8 @@ function parseToken(raw) {
   return { id: raw.slice(0, dot), secret: raw.slice(dot + 1) };
 }
 var TokenStore = class {
-  constructor(path24) {
-    this.path = path24;
+  constructor(path25) {
+    this.path = path25;
   }
   path;
   cache = null;
@@ -11514,8 +11642,8 @@ var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
 var import_types29 = require("@harness-engineering/types");
 var AuditLogger = class {
-  constructor(path24, opts = {}) {
-    this.path = path24;
+  constructor(path25, opts = {}) {
+    this.path = path25;
     this.opts = opts;
   }
   path;
@@ -11753,9 +11881,9 @@ var V1_BRIDGE_ROUTES = [
 function isV1Bridge(method, url) {
   return V1_BRIDGE_ROUTES.some((r) => r.method === method && r.pattern.test(url));
 }
-function requiredBridgeScope(method, path24) {
+function requiredBridgeScope(method, path25) {
   for (const r of V1_BRIDGE_ROUTES) {
-    if (r.method === method && r.pattern.test(path24)) return r.scope;
+    if (r.method === method && r.pattern.test(path25)) return r.scope;
   }
   return null;
 }
@@ -11765,11 +11893,11 @@ function hasScope(held, required) {
   if (held.includes("admin")) return true;
   return held.includes(required);
 }
-function exactScopeForRoute(method, path24) {
-  if (path24 === "/api/v1/auth/token" && method === "POST") return "admin";
-  if (path24 === "/api/v1/auth/tokens" && method === "GET") return "admin";
-  if (/^\/api\/v1\/auth\/tokens\/[^/]+$/.test(path24) && method === "DELETE") return "admin";
-  if ((path24 === "/api/state" || path24 === "/api/v1/state") && method === "GET") return "read-status";
+function exactScopeForRoute(method, path25) {
+  if (path25 === "/api/v1/auth/token" && method === "POST") return "admin";
+  if (path25 === "/api/v1/auth/tokens" && method === "GET") return "admin";
+  if (/^\/api\/v1\/auth\/tokens\/[^/]+$/.test(path25) && method === "DELETE") return "admin";
+  if ((path25 === "/api/state" || path25 === "/api/v1/state") && method === "GET") return "read-status";
   return null;
 }
 var PREFIX_SCOPES = [
@@ -11786,19 +11914,19 @@ var PREFIX_SCOPES = [
   ["/api/sessions", "read-status"],
   ["/api/chat-proxy", "trigger-job"]
 ];
-function prefixScopeForPath(path24) {
-  if (path24 === "/api/chat") return "trigger-job";
+function prefixScopeForPath(path25) {
+  if (path25 === "/api/chat") return "trigger-job";
   for (const [prefix, scope] of PREFIX_SCOPES) {
-    if (path24.startsWith(prefix)) return scope;
+    if (path25.startsWith(prefix)) return scope;
   }
   return null;
 }
-function requiredScopeForRoute(method, path24) {
-  const bridgeScope = requiredBridgeScope(method, path24);
+function requiredScopeForRoute(method, path25) {
+  const bridgeScope = requiredBridgeScope(method, path25);
   if (bridgeScope) return bridgeScope;
-  const exactScope = exactScopeForRoute(method, path24);
+  const exactScope = exactScopeForRoute(method, path25);
   if (exactScope) return exactScope;
-  return prefixScopeForPath(path24);
+  return prefixScopeForPath(path25);
 }
 
 // src/server/http.ts
@@ -12327,8 +12455,8 @@ function genSecret2() {
   return (0, import_node_crypto10.randomBytes)(32).toString("base64url");
 }
 var WebhookStore = class {
-  constructor(path24) {
-    this.path = path24;
+  constructor(path25) {
+    this.path = path25;
   }
   path;
   cache = null;
@@ -15173,8 +15301,8 @@ function validateCheckShape(prefix, task, errors) {
     });
   }
   if (hasScript) {
-    const path24 = task.checkScript?.path;
-    if (!path24 || path24.trim().length === 0) {
+    const path25 = task.checkScript?.path;
+    if (!path25 || path25.trim().length === 0) {
       errors.push({ path: `${prefix}.checkScript.path`, message: "checkScript.path is required" });
     }
     if (task.checkScript?.timeoutMs !== void 0 && task.checkScript.timeoutMs <= 0) {
@@ -15300,9 +15428,9 @@ function handleEdge(top, next, color, stack, errors, reported) {
     stack.push({ id: next, nextIdx: 0, path: [...top.path, next] });
   }
 }
-function reportCycle(path24, next, errors, reported) {
-  const cycleStart = path24.indexOf(next);
-  const cyclePath = cycleStart >= 0 ? [...path24.slice(cycleStart), next] : [...path24, next];
+function reportCycle(path25, next, errors, reported) {
+  const cycleStart = path25.indexOf(next);
+  const cyclePath = cycleStart >= 0 ? [...path25.slice(cycleStart), next] : [...path25, next];
   const key = cyclePath.join("\u2192");
   if (reported.has(key)) return;
   reported.add(key);
@@ -16790,7 +16918,9 @@ ${messages}`);
             await this.emitWorkerExit(issue.id, "error", attempt, "Stopped by reconciliation");
           }
         } else {
-          const outcomeClass = await this.deriveSingleAgentQualityVerdict(issue, workspacePath);
+          const qualityClass = await this.deriveSingleAgentQualityVerdict(issue, workspacePath);
+          const retroClass = await this.deriveRoutingRetrospectiveVerdict(issue, workspacePath);
+          const outcomeClass = qualityClass ?? retroClass;
           await this.emitWorkerExit(issue.id, "normal", attempt, void 0, outcomeClass);
         }
       } catch (error) {
@@ -16865,7 +16995,7 @@ ${messages}`);
     try {
       const diff = await this.workspace.getIntroducedDiffText(issue.identifier);
       if (diff.trim() === "") return void 0;
-      const evaluator = new import_intelligence11.OutcomeEvaluator(provider, this.graphStore ?? new import_graph2.GraphStore(), {
+      const evaluator = new import_intelligence12.OutcomeEvaluator(provider, this.graphStore ?? new import_graph2.GraphStore(), {
         ...acceptanceEval.model !== void 0 ? { model: acceptanceEval.model } : {}
       });
       const verdict = await evaluator.evaluate({
@@ -16892,6 +17022,150 @@ ${messages}`);
       return void 0;
     }
   }
+  /**
+   * Roadmap Auto-Triage Phase 4 (SC1–SC3, SC5, SC7): the post-diff routing
+   * retrospective — a SIBLING quality-verdict source to the 4c feeder above,
+   * extending (not replacing) the proven escalation path. On a normal exit, when AMR
+   * is live AND auto-triage is enabled AND this unit carries a stored pre-dispatch
+   * prediction, it classifies the ACTUAL introduced diff at full strength
+   * (phase:'post-diff') and grades it against that prediction:
+   *   - MATCH   → records the graded outcome + annotates the PR "AI autonomous —
+   *               verify" (stage-2 human-verify handling, SC4) → returns `undefined`
+   *               (neutral: a match is not an escalation).
+   *   - MISMATCH (diff exceeded prediction, or a missing/garbled prediction, or ANY
+   *               error) → records the outcome (when a shape is known) + returns
+   *               `'quality-fail'`, which climbs the coherence unit's escalation floor
+   *               via `recordAmrOutcome`; exhaustion queues `needs-human` (SC3/SC7).
+   *
+   * Fail-safe & guarded (SC7): an error never a silent pass — it takes the MISMATCH
+   * (block+escalate) path. No-op (byte-identical) when AMR is off, auto-triage is
+   * off, or the unit was not dispatched through triage (no stored prediction) — the
+   * last means an ordinary non-triaged run is never graded.
+   */
+  async deriveRoutingRetrospectiveVerdict(issue, _workspacePath) {
+    if (this.adaptiveRouter === null) return void 0;
+    if (this.config.roadmap?.autoTriage?.enabled !== true) return void 0;
+    const externalId = issue.externalId;
+    if (externalId === null || externalId === "") return void 0;
+    let record;
+    try {
+      const loaded = await import_core17.eventSourcing.loadTriageRecords(this.projectRoot);
+      if (!loaded.ok) throw loaded.error;
+      record = loaded.value.find((r) => r.externalId === externalId);
+    } catch (err) {
+      this.logger.debug("amr retrospective skipped (record load failed)", {
+        issueId: issue.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (issue.spec !== null && issue.spec !== void 0 && issue.spec !== "") {
+        this.logger.info(
+          "amr:quality-fail \u2014 spec-bearing (triaged) unit but the triage store is unreadable (fail-safe block: a triaged unit whose prediction we cannot read never silently passes)",
+          { issueId: issue.id, externalId }
+        );
+        return "quality-fail";
+      }
+      return void 0;
+    }
+    if (record === void 0) return void 0;
+    const stored = record.prediction;
+    if (stored === void 0) {
+      this.logger.info(
+        "amr:quality-fail \u2014 triaged unit has no stored prediction (fail-safe block)",
+        {
+          issueId: issue.id,
+          externalId
+        }
+      );
+      return "quality-fail";
+    }
+    const prediction = {
+      verdict: stored.verdict,
+      levers: stored.levers,
+      scopeEstimate: stored.scopeEstimate,
+      ratchetStage: stored.ratchetStage
+    };
+    try {
+      const hunks = await this.workspace.getIntroducedDiff(issue.identifier);
+      const taskText = buildTaskText(issue);
+      const exceededByBands = this.config.roadmap?.autoTriage?.thresholds?.exceededByBands ?? 1;
+      const result = await runRetrospective(
+        {
+          hunks,
+          textOnly: {
+            descriptionLength: taskText.descriptionLength,
+            specExists: taskText.specExists,
+            acceptanceMeasurable: taskText.acceptanceMeasurable
+          },
+          prediction,
+          riskHigh: false,
+          prompt: taskText.prompt,
+          comparatorConfig: { exceededByBands }
+        },
+        this.resolveComplexityProvider()
+      );
+      const outcomeInput = buildTriageOutcomeInput(externalId, record.shapeKey, result);
+      const recorded = await import_core17.eventSourcing.recordTriageOutcome(this.projectRoot, outcomeInput);
+      if (!recorded.ok) {
+        this.logger.warn("amr retrospective outcome record failed (best-effort)", {
+          issueId: issue.id,
+          error: recorded.error.message
+        });
+      }
+      if (result.comparison.action === "block-escalate") {
+        this.logger.info("amr:quality-fail \u2014 post-diff retrospective mispredict (block+escalate)", {
+          issueId: issue.id,
+          externalId,
+          predicted: prediction.verdict.level,
+          actual: result.actual.level,
+          exceededBy: result.comparison.exceededBy
+        });
+        return "quality-fail";
+      }
+      await this.annotateRetrospectiveMatch(issue, externalId, result.actual.level);
+      return void 0;
+    } catch (err) {
+      this.logger.info("amr:quality-fail \u2014 post-diff retrospective errored (fail-safe block)", {
+        issueId: issue.id,
+        externalId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return "quality-fail";
+    }
+  }
+  /**
+   * v1 stage-2 match handling (SC4): annotate the unit's PR/issue with a "verify this
+   * autonomous change" note so a human reviews every autonomous PR. Best-effort — a
+   * missing tracker config / token / a failed comment never breaks completion (the
+   * grade already recorded above). Mirrors `postLifecycleComment`'s adapter wiring.
+   */
+  async annotateRetrospectiveMatch(issue, externalId, actualLevel) {
+    try {
+      const trackerConfig = (0, import_core17.loadTrackerSyncConfig)(this.projectRoot);
+      if (!trackerConfig) return;
+      const token = process.env.GITHUB_TOKEN;
+      if (!token) return;
+      const orchestratorId = await this.orchestratorIdPromise;
+      const adapter = new import_core17.GitHubIssuesSyncAdapter({ token, config: trackerConfig });
+      const body = [
+        `**AI autonomous change \u2014 please verify** \`${orchestratorId}\``,
+        "",
+        "The post-diff retrospective classified this change WITHIN its pre-dispatch",
+        `prediction (actual complexity: \`${actualLevel}\`). Under autonomy ratchet`,
+        "stage 2, a human must verify every autonomous PR before it merges."
+      ].join("\n");
+      const result = await adapter.addComment(externalId, body);
+      if (!result.ok) {
+        this.logger.warn(`amr retrospective annotation failed for ${issue.identifier}`, {
+          error: result.error.message
+        });
+      }
+    } catch (err) {
+      this.logger.debug("amr retrospective annotation skipped (best-effort)", {
+        issueId: issue.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   /**
    * Informs the state machine that an agent worker has exited.
    */
@@ -17978,6 +18252,333 @@ function launchTUI(orchestrator) {
   return { waitUntilExit };
 }
 
+// src/agent/triage-wiring.ts
+var import_graph3 = require("@harness-engineering/graph");
+var import_intelligence13 = require("@harness-engineering/intelligence");
+function buildProbeInput(issue) {
+  const taskText = buildTaskText(issue);
+  const combined = `${issue.title ?? ""}
+${issue.description ?? ""}`.trim();
+  return {
+    // An item lacking a stable externalId is not dispatch-eligible (proposal Assumptions);
+    // we still probe it (read-only report), keyed by its identifier as a fallback.
+    externalId: issue.externalId ?? issue.identifier ?? issue.id,
+    taskText,
+    entityCandidates: (0, import_intelligence13.extractEntities)(combined),
+    labels: issue.labels ?? []
+  };
+}
+function findNode(store, candidate) {
+  const trimmed = candidate.trim();
+  if (trimmed.length === 0) return null;
+  const byName = store.findNodes({ name: trimmed });
+  if (byName.length > 0) return byName[0] ?? null;
+  const byPath = store.findNodes({ path: trimmed });
+  if (byPath.length > 0) return byPath[0] ?? null;
+  const byId = store.getNode(`file:${trimmed}`);
+  if (byId) return byId;
+  return null;
+}
+function makeGraphScope(store) {
+  const simulator = new import_graph3.CascadeSimulator(store);
+  return {
+    resolve(candidate) {
+      try {
+        const node = findNode(store, candidate);
+        if (!node) return null;
+        const result = simulator.simulate(node.id);
+        return {
+          candidate,
+          nodeId: node.id,
+          blastRadius: result.summary.totalAffected
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+async function triageIssue2(issue, deps = {}) {
+  const input = buildProbeInput(issue);
+  const graph = deps.graphStore ? makeGraphScope(deps.graphStore) : void 0;
+  return (0, import_intelligence13.runScopingProbe)(input, {
+    ...deps.provider ? { provider: deps.provider } : {},
+    ...graph ? { graph } : {},
+    ...deps.precedent ? { precedent: deps.precedent } : {},
+    ...deps.config ? { config: deps.config } : {},
+    ...deps.models ? { models: deps.models } : {}
+  });
+}
+
+// src/agent/brainstorm-wiring.ts
+var fs16 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var import_zod18 = require("zod");
+var import_intelligence14 = require("@harness-engineering/intelligence");
+var ForkStepSchema = import_zod18.z.object({
+  done: import_zod18.z.boolean().describe("true when there are no more design forks to decide"),
+  forkId: import_zod18.z.string().describe('short stable id for this fork, e.g. "storage-backend"').optional(),
+  question: import_zod18.z.string().describe("the design question this fork decides").optional(),
+  options: import_zod18.z.array(import_zod18.z.string()).describe("the mutually-exclusive options considered").optional(),
+  // The AUTHORITATIVE recommendation validity checks (non-empty AND one of `options`) live in
+  // the GENERATOR, where `fork.options` is known and where a degenerate value must map to a
+  // `confidence:'low'` DOWNGRADE (→ runner halts with reason 'low-confidence'), not a hard
+  // schema/provider throw. We deliberately keep this `optional()`/unconstrained so an empty or
+  // absent recommendation still reaches the generator's semantic gate rather than short-
+  // circuiting to `halted{ reason:'error' }`. See makeSelForkGenerator's SAFETY GATE 2.
+  recommendation: import_zod18.z.string().describe("the recommended option (one of options)").optional(),
+  confidence: import_zod18.z.enum(["high", "medium", "low"]).describe("self-assessed confidence in the recommendation").optional(),
+  rationale: import_zod18.z.string().describe("why this option").optional()
+});
+var BRAINSTORM_RUBRIC = 'You are running an AUTONOMOUS brainstorm over one backlog item: enumerate each design fork (a decision with mutually-exclusive options), then recommend a default for the NEXT unresolved fork with a self-assessed confidence. Report confidence HIGH only when the recommendation is clearly correct on technical grounds alone. Report LOW (so a human decides) whenever the fork involves ANY of: a product or UX tradeoff, an unrevealed business priority, a security-sensitive or irreversible/outward-facing action, or a genuine judgment call between comparable options. Never invent forks to pad the spec; set done=true once every real fork is resolved. Be conservative \u2014 a false "high" is far more costly than asking a human.';
+function makeSelForkGenerator(provider, input, opts = {}) {
+  const samples = Math.max(2, opts.samples ?? 3);
+  const maxTokens = opts.maxTokens ?? 512;
+  return {
+    async next(index, priorDecisions) {
+      const prompt = buildForkPrompt(input, priorDecisions, index);
+      const steps = [];
+      for (let s = 0; s < samples; s++) {
+        const { result } = await provider.analyze({
+          prompt,
+          systemPrompt: BRAINSTORM_RUBRIC,
+          responseSchema: ForkStepSchema,
+          maxTokens,
+          ...opts.model !== void 0 ? { model: opts.model } : {}
+        });
+        steps.push(result);
+      }
+      if (steps.some((st) => st.done)) return null;
+      const first = steps[0];
+      if (!first) return null;
+      const fork = {
+        id: first.forkId ?? `fork-${index}`,
+        question: first.question ?? "unspecified fork",
+        options: first.options ?? []
+      };
+      const recommendation = first.recommendation ?? "";
+      const normQ = (q) => (q ?? "").trim().toLowerCase();
+      const firstForkId = first.forkId ?? "";
+      const firstQuestion = normQ(first.question);
+      const identityStable = steps.every(
+        (st) => (st.forkId ?? "") === firstForkId && normQ(st.question) === firstQuestion
+      );
+      const recStable = steps.every((st) => (st.recommendation ?? "") === recommendation);
+      const recEmpty = recommendation.trim() === "";
+      const recNotAnOption = !recEmpty && fork.options.length > 0 && !fork.options.includes(recommendation);
+      const stable = identityStable && recStable && !recEmpty && !recNotAnOption;
+      const reported = first.confidence ?? "low";
+      const confidence = stable ? reported : "low";
+      let downgradeReason = "";
+      if (!identityStable) {
+        downgradeReason = `fork identity drift across ${samples} samples (self-consistency downgrade to low): ` + steps.map((st) => `${st.forkId ?? "\u2205"}:"${(st.question ?? "\u2205").trim()}"`).join(" / ");
+      } else if (recEmpty) {
+        downgradeReason = "recommendation was empty/absent (a content-free recommendation is not a confident decision; downgrade to low)";
+      } else if (recNotAnOption) {
+        downgradeReason = `recommendation '${recommendation}' is not one of the offered options [${fork.options.join(", ")}] (downgrade to low)`;
+      } else if (!recStable) {
+        downgradeReason = `recommendation was unstable across ${samples} samples (self-consistency downgrade to low): ` + steps.map((st) => st.recommendation ?? "\u2205").join(" / ");
+      }
+      return {
+        fork,
+        recommendation,
+        confidence,
+        rationale: stable ? first.rationale ?? "" : downgradeReason
+      };
+    }
+  };
+}
+function buildForkPrompt(input, priorDecisions, index) {
+  const resolved = priorDecisions.length === 0 ? "(none yet)" : priorDecisions.map((d, i) => `${i + 1}. ${d.fork.question} \u2192 ${d.recommendation}`).join("\n");
+  return `Item: ${input.title}
+Summary: ${input.summary}
+Complexity: ${input.level}
+
+Forks already resolved:
+${resolved}
+
+Decide fork #${index + 1}: the NEXT unresolved design fork. If every real fork is already resolved, return { "done": true }.`;
+}
+function brainstormInputFromIssue(issue, level) {
+  return {
+    externalId: issue.externalId ?? issue.identifier ?? issue.id,
+    title: issue.title ?? issue.identifier ?? issue.id,
+    summary: issue.description ?? "",
+    level
+  };
+}
+async function runBrainstormForIssue(issue, level, deps) {
+  const input = brainstormInputFromIssue(issue, level);
+  const generator = deps.generator ?? (deps.provider ? makeSelForkGenerator(deps.provider, input, deps.generatorOptions ?? {}) : void 0);
+  if (!generator) {
+    return {
+      outcome: {
+        kind: "halted",
+        fork: { id: "no-generator", question: "no fork generator or provider wired", options: [] },
+        reason: "error",
+        detail: "runBrainstormForIssue requires either an injected generator or a SEL provider"
+      }
+    };
+  }
+  const depth = (0, import_intelligence14.depthForLevel)(level);
+  const outcome = await (0, import_intelligence14.runAutoBrainstorm)(input, generator, depth);
+  if (outcome.kind !== "completed") {
+    return { outcome };
+  }
+  const result = { outcome };
+  if (deps.docsRoot) {
+    try {
+      result.specPath = writeSpecDoc(deps.docsRoot, outcome.spec);
+    } catch {
+    }
+  }
+  if (deps.rescore) {
+    try {
+      const enrichedIssue = enrichIssueWithSpec(issue, outcome.spec);
+      result.rescore = await triageIssue2(enrichedIssue, {
+        ...deps.rescore.graphStore ? { graphStore: deps.rescore.graphStore } : {},
+        ...deps.rescore.provider ? { provider: deps.rescore.provider } : {},
+        ...deps.rescore.precedent ? { precedent: deps.rescore.precedent } : {},
+        ...deps.rescore.config ? { config: deps.rescore.config } : {},
+        ...deps.rescore.models ? { models: deps.rescore.models } : {}
+      });
+    } catch {
+    }
+  }
+  return result;
+}
+function slugFor(spec) {
+  const base = spec.title || spec.externalId;
+  return base.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "item";
+}
+function renderSpecMarkdown(spec) {
+  const lines = [];
+  lines.push(`# ${spec.title}`);
+  lines.push("");
+  lines.push("Status: **Auto-drafted (autonomous brainstorm \u2014 awaiting human review)**");
+  lines.push("");
+  lines.push(`Item: \`${spec.externalId}\``);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(spec.summary || "_No summary provided._");
+  lines.push("");
+  lines.push("## Design decisions");
+  lines.push("");
+  if (spec.decisions.length === 0) {
+    lines.push("_No forks required a decision \u2014 the item was unambiguous._");
+  } else {
+    for (const [i, d] of spec.decisions.entries()) {
+      lines.push(`### ${i + 1}. ${d.fork.question}`);
+      lines.push("");
+      if (d.fork.options.length > 0) {
+        lines.push(`Options considered: ${d.fork.options.map((o) => `\`${o}\``).join(", ")}`);
+        lines.push("");
+      }
+      lines.push(`**Recommendation:** ${d.recommendation} (confidence: ${d.confidence})`);
+      lines.push("");
+      if (d.rationale) {
+        lines.push(d.rationale);
+        lines.push("");
+      }
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(
+    "_This spec was drafted autonomously. Every fork above cleared the high-confidence bar; any fork the system could not confidently resolve would have halted the brainstorm and handed that fork to a human instead._"
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function writeSpecDoc(docsRoot, spec) {
+  const dir = path22.join(docsRoot, "changes", slugFor(spec));
+  fs16.mkdirSync(dir, { recursive: true });
+  const file = path22.join(dir, "proposal.md");
+  fs16.writeFileSync(file, renderSpecMarkdown(spec), "utf-8");
+  return file;
+}
+function enrichIssueWithSpec(issue, spec) {
+  const decisionText = spec.decisions.map((d) => `${d.fork.question} \u2192 ${d.recommendation}. ${d.rationale}`).join("\n");
+  const enrichedDescription = [issue.description ?? "", decisionText].filter(Boolean).join("\n\n");
+  return {
+    ...issue,
+    description: enrichedDescription,
+    // The item now HAS a drafted spec — reflect it so the re-score's spec-exists signal is true.
+    spec: issue.spec ?? `changes/${slugFor(spec)}/proposal.md`
+  };
+}
+
+// src/agent/triage-mark.ts
+var import_core20 = require("@harness-engineering/core");
+var import_intelligence15 = require("@harness-engineering/intelligence");
+var ELIGIBLE_STATUS = "planned";
+async function markApprovedForDispatch(items, deps) {
+  const { store, config, recordPrediction, selfAssignee } = deps;
+  if (!config.enabled) {
+    return { ok: true, value: { marked: [], skipped: [] } };
+  }
+  const loaded = await store.load();
+  if (!loaded.ok) return { ok: false, error: loaded.error };
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const m of loaded.value.milestones) {
+    for (const f of m.features) bySlug.set((0, import_core20.slugifyFeatureName)(f.name), f);
+  }
+  const marked = [];
+  const skipped = [];
+  for (const it of items) {
+    const externalId = it.candidate.externalId;
+    if (!it.candidate.humanApproved) {
+      skipped.push({ externalId, reason: "not-approved" });
+      continue;
+    }
+    const slug = (0, import_core20.slugifyFeatureName)(it.featureName);
+    const target = bySlug.get(slug);
+    if (!target) {
+      skipped.push({ externalId, reason: "feature-not-found" });
+      continue;
+    }
+    if (selfAssignee !== void 0 && target.assignee != null && target.assignee !== selfAssignee) {
+      skipped.push({ externalId, reason: "assigned-elsewhere" });
+      continue;
+    }
+    const mutate = (f) => ({
+      ...f,
+      spec: it.specPath,
+      status: isActiveStatus(f.status) ? f.status : ELIGIBLE_STATUS
+    });
+    const patched = await store.patchFeature(slug, mutate);
+    if (!patched.ok) return { ok: false, error: patched.error };
+    const key = (0, import_intelligence15.dispatchableShapeKey)(it.labels, it.verdict.level);
+    const prediction = {
+      externalId,
+      shapeKey: key,
+      verdict: it.verdict,
+      // `levers` is an OPAQUE DIAGNOSTIC SNAPSHOT (the verdict's static signals), NOT the
+      // typed ProbeLevers. The Phase-4 comparator grades on `verdict.level` +
+      // `scopeEstimate` ONLY (see retrospective.ts) and never reads `levers`, so this
+      // human-legible signal dump cannot mislead the grade. The full typed ProbeLevers
+      // are not threaded here on purpose (it would balloon ReadyCandidate→marker for a
+      // field nothing downstream consumes); `record.ts` re-documents the field to match.
+      levers: it.verdict.signals,
+      scopeEstimate: it.scopeEstimate,
+      // Prefer the per-shape evidence-derived stage (SC6) when the caller resolved one;
+      // fall back to the uniform config stage (Phase-3 behavior). Cold-start ⇒ the caller
+      // resolves stage 1, so this is byte-identical to `config.ratchetStage` at cold-start.
+      ratchetStage: it.effectiveStage ?? config.ratchetStage
+    };
+    const recorded = await recordPrediction(prediction);
+    if (!recorded.ok) {
+      return { ok: false, error: recorded.error ?? new Error("recordPrediction failed") };
+    }
+    marked.push(externalId);
+  }
+  return { ok: true, value: { marked, skipped } };
+}
+function isActiveStatus(status) {
+  return status === "planned" || status === "in-progress";
+}
+
 // src/maintenance/sync-main.ts
 var import_node_child_process14 = require("child_process");
 var import_node_util5 = require("util");
@@ -18171,8 +18772,8 @@ function selectTasks(tasks, history, filter) {
 }
 
 // src/sessions/search-index.ts
-var fs16 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var import_better_sqlite32 = __toESM(require("better-sqlite3"));
 var import_types35 = require("@harness-engineering/types");
 var SEARCH_INDEX_FILE = "search-index.sqlite";
@@ -18217,7 +18818,7 @@ function normalizeFts5Query(query) {
   return query.split(/\s+/).filter((tok) => tok.length > 0).map((tok) => `"${tok.replace(/"/g, '""')}"`).join(" ");
 }
 function searchIndexPath(projectPath) {
-  return path22.join(projectPath, ".harness", SEARCH_INDEX_FILE);
+  return path23.join(projectPath, ".harness", SEARCH_INDEX_FILE);
 }
 var FILE_KIND_TO_FILENAME = {
   summary: "summary.md",
@@ -18232,7 +18833,7 @@ var SqliteSearchIndex = class {
   removeSessionStmt;
   totalStmt;
   constructor(dbPath) {
-    fs16.mkdirSync(path22.dirname(dbPath), { recursive: true });
+    fs17.mkdirSync(path23.dirname(dbPath), { recursive: true });
     this.db = new import_better_sqlite32.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
@@ -18337,14 +18938,14 @@ function indexSessionDirectory(idx, args) {
   let docsWritten = 0;
   for (const kind of kinds) {
     const fileName = FILE_KIND_TO_FILENAME[kind];
-    const filePath = path22.join(args.sessionDir, fileName);
-    if (!fs16.existsSync(filePath)) continue;
-    let body = fs16.readFileSync(filePath, "utf8");
+    const filePath = path23.join(args.sessionDir, fileName);
+    if (!fs17.existsSync(filePath)) continue;
+    let body = fs17.readFileSync(filePath, "utf8");
     if (Buffer.byteLength(body, "utf8") > cap) {
       body = body.slice(0, cap) + "\n\n[TRUNCATED]";
     }
-    const stat = fs16.statSync(filePath);
-    const relPath = path22.relative(args.projectPath, filePath).replaceAll("\\", "/");
+    const stat = fs17.statSync(filePath);
+    const relPath = path23.relative(args.projectPath, filePath).replaceAll("\\", "/");
     idx.upsertSessionDoc({
       sessionId: args.sessionId,
       archived: args.archived,
@@ -18359,17 +18960,17 @@ function indexSessionDirectory(idx, args) {
 }
 function reindexFromArchive(projectPath, opts = {}) {
   const start = Date.now();
-  const archiveBase = path22.join(projectPath, ".harness", "archive", "sessions");
+  const archiveBase = path23.join(projectPath, ".harness", "archive", "sessions");
   const idx = openSearchIndex(projectPath);
   try {
     idx.resetArchived();
     let sessionsIndexed = 0;
     let docsWritten = 0;
-    if (fs16.existsSync(archiveBase)) {
-      const entries = fs16.readdirSync(archiveBase, { withFileTypes: true });
+    if (fs17.existsSync(archiveBase)) {
+      const entries = fs17.readdirSync(archiveBase, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const sessionDir = path22.join(archiveBase, entry.name);
+        const sessionDir = path23.join(archiveBase, entry.name);
         const result = indexSessionDirectory(idx, {
           sessionId: entry.name,
           sessionDir,
@@ -18389,8 +18990,8 @@ function reindexFromArchive(projectPath, opts = {}) {
 }
 
 // src/sessions/summarize.ts
-var fs17 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var import_types36 = require("@harness-engineering/types");
 var import_types37 = require("@harness-engineering/types");
 var LLM_SUMMARY_FILE = "llm-summary.md";
@@ -18418,10 +19019,10 @@ var USER_PROMPT_PREAMBLE = `Below are the archived files for a single harness-en
 function readInputCorpus(archiveDir) {
   const parts = [];
   for (const { filename, kind } of SUMMARY_INPUT_FILES) {
-    const p = path23.join(archiveDir, filename);
-    if (!fs17.existsSync(p)) continue;
+    const p = path24.join(archiveDir, filename);
+    if (!fs18.existsSync(p)) continue;
     try {
-      const content = fs17.readFileSync(p, "utf8");
+      const content = fs18.readFileSync(p, "utf8");
       if (content.trim().length === 0) continue;
       parts.push(`## FILE: ${kind}
 
@@ -18472,7 +19073,7 @@ function renderLlmSummaryMarkdown(summary, meta) {
   return lines.join("\n");
 }
 function writeStubMarkdown(archiveDir, reason) {
-  const filePath = path23.join(archiveDir, LLM_SUMMARY_FILE);
+  const filePath = path24.join(archiveDir, LLM_SUMMARY_FILE);
   const body = `---
 generatedAt: ${(/* @__PURE__ */ new Date()).toISOString()}
 schemaVersion: 1
@@ -18483,12 +19084,12 @@ status: failed
 
 - reason: ${reason}
 `;
-  fs17.writeFileSync(filePath, body, "utf8");
+  fs18.writeFileSync(filePath, body, "utf8");
   return filePath;
 }
 async function summarizeArchivedSession(ctx) {
   const writeStubOnError = ctx.writeStubOnError ?? true;
-  if (!fs17.existsSync(ctx.archiveDir)) {
+  if (!fs18.existsSync(ctx.archiveDir)) {
     return (0, import_types37.Err)(new Error(`archive directory not found: ${ctx.archiveDir}`));
   }
   const corpus = readInputCorpus(ctx.archiveDir);
@@ -18549,9 +19150,9 @@ async function summarizeArchivedSession(ctx) {
     outputTokens: response.tokenUsage.outputTokens,
     schemaVersion: 1
   };
-  const filePath = path23.join(ctx.archiveDir, LLM_SUMMARY_FILE);
+  const filePath = path24.join(ctx.archiveDir, LLM_SUMMARY_FILE);
   const body = renderLlmSummaryMarkdown(parsed.data, meta);
-  fs17.writeFileSync(filePath, body, "utf8");
+  fs18.writeFileSync(filePath, body, "utf8");
   return (0, import_types37.Ok)({ summary: parsed.data, meta, filePath });
 }
 function isSummaryEnabled(config) {
@@ -18633,6 +19234,7 @@ var import_local_models7 = require("@harness-engineering/local-models");
 0 && (module.exports = {
   AdaptiveRouter,
   AnalysisArchive,
+  BRAINSTORM_RUBRIC,
   BUILT_IN_TASKS,
   BackendDefSchema,
   BackendRouter,
@@ -18675,8 +19277,10 @@ var import_local_models7 = require("@harness-engineering/local-models");
   WorkspaceManager,
   applyEvent,
   artifactPresenceFromIssue,
+  brainstormInputFromIssue,
   buildArchiveHooks,
   buildCapabilityRegistry,
+  buildProbeInput,
   buildWorkflowContext,
   calculateRetryDelay,
   canDispatch,
@@ -18696,6 +19300,7 @@ var import_local_models7 = require("@harness-engineering/local-models");
   emitProposalApproved,
   emitProposalCreated,
   emitProposalRejected,
+  enrichIssueWithSpec,
   estimateCost,
   explicitFindingsCount,
   extractHighlights,
@@ -18710,22 +19315,30 @@ var import_local_models7 = require("@harness-engineering/local-models");
   launchTUI,
   loadPublishedIndex,
   makeBackendResolver,
+  makeGraphScope,
+  makeSelForkGenerator,
+  markApprovedForDispatch,
   migrateAgentConfig,
   normalizeFts5Query,
   normalizeHarnessCommand,
   normalizeLocalModel,
   openSearchIndex,
+  pilotScore,
+  precedentLookupFromStored,
   promote,
+  rankTriageCandidates,
   reconcile,
   recoverFindingsCount,
   reindexFromArchive,
   renderAnalysisComment,
   renderLlmSummaryMarkdown,
   renderPRComment,
+  renderSpecMarkdown,
   resolveEscalationConfig,
   resolveOrchestratorId,
   routeIssue,
   routingWarnings,
+  runBrainstormForIssue,
   runGate,
   runHarnessCheck,
   savePublishedIndex,
@@ -18733,6 +19346,7 @@ var import_local_models7 = require("@harness-engineering/local-models");
   selectCandidates,
   selectCheapestQualifying,
   selectTasks,
+  slugFor,
   sortCandidates,
   summarizeArchivedSession,
   syncMain,