@harness-engineering/orchestrator 0.14.0 → 0.15.1

package/dist/index.mjs

@@ -2013,6 +2013,31 @@ var RoutingConfigSchema = z.object({
   // when absent). Previously accepted by the runtime PUT endpoint only. ---
   policy: RoutingPolicySchema.optional()
 }).strict();
+var CONFIDENCE = z.enum(["low", "medium", "high"]);
+var V1_MAX_RATCHET_STAGE = 2;
+var RATCHET_STAGE = z.union([z.literal(1), z.literal(2), z.literal(3), 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 = z.object({
+  enabled: z.boolean(),
+  schedule: z.string().min(1).optional(),
+  ratchetStage: RATCHET_STAGE,
+  thresholds: z.object({
+    dispatchConfidence: CONFIDENCE,
+    boundedScopeMax: z.number(),
+    brainstormConfidence: z.number(),
+    exceededByBands: z.number(),
+    ratchetAdvanceRate: z.number(),
+    ratchetMinSample: z.number()
+  }).strict(),
+  depthBudget: z.object({
+    trivial: z.number(),
+    simple: z.number()
+  }).strict()
+}).strict();
+var RoadmapConfigSchema = z.object({
+  autoTriage: RoadmapAutoTriageSchema.optional()
+}).strict();
 var WorkflowStepSchema = z.object({
   skill: z.string().min(1),
   produces: z.string().min(1),
@@ -2050,12 +2075,12 @@ var BackendsMapSchema = z2.record(z2.string(), BackendDefSchema);
 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(", ")}].`
@@ -2152,6 +2177,10 @@ function validateWorkflowConfig(config, options = {}) {
     const parsed = z2.array(StagedWorkflowDeclSchema).safeParse(c.workflows);
     if (!parsed.success) return Err(new Error(`workflows: ${parsed.error.message}`));
   }
+  if (c.roadmap !== void 0) {
+    const parsed = RoadmapConfigSchema.safeParse(c.roadmap);
+    if (!parsed.success) return Err(new Error(`roadmap: ${parsed.error.message}`));
+  }
   return Ok2({ config, warnings });
 }
 function getDefaultConfig() {
@@ -3406,6 +3435,68 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { RoutingError as RoutingError3 } from "@harness-engineering/types";
 import { writeTaint, SecurityScanner as SecurityScanner2 } from "@harness-engineering/core";
 import { OutcomeEvaluator } from "@harness-engineering/intelligence";
+
+// src/agent/triage-outcome.ts
+import {
+  classify,
+  compareToPrediction,
+  aggregatePrecedent
+} from "@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 classify(
+    { signals, phase: "post-diff", riskHigh: deps.riskHigh, prompt: deps.prompt },
+    provider
+  );
+  const comparison = deps.comparatorConfig ? compareToPrediction(deps.prediction, actual, deps.comparatorConfig) : 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) => aggregatePrecedent(bridged, shapeKey)
+  };
+}
+
+// src/orchestrator.ts
 import { GraphStore as GraphStore2 } from "@harness-engineering/graph";
 
 // src/core/stall-detector.ts
@@ -3989,7 +4080,8 @@ var CompletionHandler = class {
 import {
   GitHubIssuesSyncAdapter as GitHubIssuesSyncAdapter3,
   loadTrackerSyncConfig as loadTrackerSyncConfig3,
-  createTrackerClient as createTrackerClient2
+  createTrackerClient as createTrackerClient2,
+  eventSourcing as eventSourcing2
 } from "@harness-engineering/core";
 
 // src/tracker/adapters/github-issues-issue-tracker.ts
@@ -4701,11 +4793,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;
@@ -4733,7 +4825,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 },
@@ -4818,12 +4910,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;
@@ -4842,7 +4934,7 @@ var BackendRouter = class {
       return {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         useCase,
-        resolutionPath: path24,
+        resolutionPath: path25,
         backendName,
         backendType: def.type,
         durationMs: performance.now() - startedAt
@@ -4875,7 +4967,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}].`
     );
   }
   /**
@@ -4968,7 +5060,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_}].`
@@ -8321,7 +8413,7 @@ function buildRoutingUseCase(issue, backendParam, catalog) {
 
 // src/agent/live-classify.ts
 import {
-  classify
+  classify as classify2
 } from "@harness-engineering/intelligence";
 var CONSERVATIVE = {
   level: "moderate",
@@ -8345,7 +8437,7 @@ function makeLiveClassify(resolveProvider) {
       riskHigh,
       prompt: taskText.prompt
     };
-    return classify(input, resolveProvider());
+    return classify2(input, resolveProvider());
   };
 }
 
@@ -10745,7 +10837,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);
@@ -10810,7 +10907,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,
@@ -10822,9 +10919,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;
     }
@@ -11386,8 +11486,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;
@@ -11494,8 +11594,8 @@ import { appendFile, mkdir as mkdir8 } from "fs/promises";
 import { dirname as dirname6 } from "path";
 import { AuthAuditEntrySchema } from "@harness-engineering/types";
 var AuditLogger = class {
-  constructor(path24, opts = {}) {
-    this.path = path24;
+  constructor(path25, opts = {}) {
+    this.path = path25;
     this.opts = opts;
   }
   path;
@@ -11733,9 +11833,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;
 }
@@ -11745,11 +11845,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 = [
@@ -11766,19 +11866,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
@@ -12307,8 +12407,8 @@ function genSecret2() {
   return randomBytes3(32).toString("base64url");
 }
 var WebhookStore = class {
-  constructor(path24) {
-    this.path = path24;
+  constructor(path25) {
+    this.path = path25;
   }
   path;
   cache = null;
@@ -15161,8 +15261,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) {
@@ -15288,9 +15388,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);
@@ -16778,7 +16878,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) {
@@ -16880,6 +16982,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 eventSourcing2.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 eventSourcing2.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 = loadTrackerSyncConfig3(this.projectRoot);
+      if (!trackerConfig) return;
+      const token = process.env.GITHUB_TOKEN;
+      if (!token) return;
+      const orchestratorId = await this.orchestratorIdPromise;
+      const adapter = new GitHubIssuesSyncAdapter3({ 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.
    */
@@ -17966,6 +18212,341 @@ function launchTUI(orchestrator) {
   return { waitUntilExit };
 }
 
+// src/agent/triage-wiring.ts
+import { CascadeSimulator } from "@harness-engineering/graph";
+import {
+  runScopingProbe,
+  extractEntities,
+  rankTriageCandidates,
+  pilotScore
+} from "@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: 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 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 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
+import * as fs16 from "fs";
+import * as path22 from "path";
+import { z as z18 } from "zod";
+import {
+  runAutoBrainstorm,
+  depthForLevel
+} from "@harness-engineering/intelligence";
+var ForkStepSchema = z18.object({
+  done: z18.boolean().describe("true when there are no more design forks to decide"),
+  forkId: z18.string().describe('short stable id for this fork, e.g. "storage-backend"').optional(),
+  question: z18.string().describe("the design question this fork decides").optional(),
+  options: z18.array(z18.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: z18.string().describe("the recommended option (one of options)").optional(),
+  confidence: z18.enum(["high", "medium", "low"]).describe("self-assessed confidence in the recommendation").optional(),
+  rationale: z18.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 = depthForLevel(level);
+  const outcome = await 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
+import { slugifyFeatureName } from "@harness-engineering/core";
+import { dispatchableShapeKey } from "@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(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 = 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 = 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
 import { execFile as nodeExecFile2 } from "child_process";
 import { promisify as promisify5 } from "util";
@@ -18159,8 +18740,8 @@ function selectTasks(tasks, history, filter) {
 }
 
 // src/sessions/search-index.ts
-import * as fs16 from "fs";
-import * as path22 from "path";
+import * as fs17 from "fs";
+import * as path23 from "path";
 import Database2 from "better-sqlite3";
 import { INDEXED_FILE_KINDS } from "@harness-engineering/types";
 var SEARCH_INDEX_FILE = "search-index.sqlite";
@@ -18205,7 +18786,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",
@@ -18220,7 +18801,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 Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
@@ -18325,14 +18906,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,
@@ -18347,17 +18928,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,
@@ -18377,8 +18958,8 @@ function reindexFromArchive(projectPath, opts = {}) {
 }
 
 // src/sessions/summarize.ts
-import * as fs17 from "fs";
-import * as path23 from "path";
+import * as fs18 from "fs";
+import * as path24 from "path";
 import {
   SessionSummarySchema
 } from "@harness-engineering/types";
@@ -18408,10 +18989,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}
 
@@ -18462,7 +19043,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
@@ -18473,12 +19054,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 Err23(new Error(`archive directory not found: ${ctx.archiveDir}`));
   }
   const corpus = readInputCorpus(ctx.archiveDir);
@@ -18539,9 +19120,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 Ok24({ summary: parsed.data, meta, filePath });
 }
 function isSummaryEnabled(config) {
@@ -18622,6 +19203,7 @@ import { discoverCandidates } from "@harness-engineering/local-models";
 export {
   AdaptiveRouter,
   AnalysisArchive,
+  BRAINSTORM_RUBRIC,
   BUILT_IN_TASKS,
   BackendDefSchema,
   BackendRouter,
@@ -18664,8 +19246,10 @@ export {
   WorkspaceManager,
   applyEvent,
   artifactPresenceFromIssue,
+  brainstormInputFromIssue,
   buildArchiveHooks,
   buildCapabilityRegistry,
+  buildProbeInput,
   buildWorkflowContext,
   calculateRetryDelay,
   canDispatch,
@@ -18685,6 +19269,7 @@ export {
   emitProposalApproved,
   emitProposalCreated,
   emitProposalRejected,
+  enrichIssueWithSpec,
   estimateCost,
   explicitFindingsCount,
   extractHighlights,
@@ -18699,22 +19284,30 @@ export {
   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,
@@ -18722,10 +19315,11 @@ export {
   selectCandidates,
   selectCheapestQualifying,
   selectTasks,
+  slugFor,
   sortCandidates,
   summarizeArchivedSession,
   syncMain,
-  triageIssue,
+  triageIssue2 as triageIssue,
   truncateForBudget,
   validateCustomTasks,
   validateWorkflowConfig,