karajan-code 4.70.3 → 5.0.0

package/src/orchestrator/stages/domain-curator-stage.js

@@ -1,82 +0,0 @@
-/**
- * Domain Curator stage logic.
- * Runs the Domain Curator role to discover and synthesize domain knowledge.
- * Slots after Triage and before Researcher/Architect/Planner.
- */
-
-import { DomainCuratorRole } from "../../roles/domain-curator-role.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
-
-/**
- * @param {Object} params
- * @param {Object} params.config
- * @param {Object} params.logger
- * @param {Object} params.emitter
- * @param {Object} params.eventBase
- * @param {Object} params.session
- * @param {Function} params.trackBudget
- * @param {string[]} params.domainHints — from triage
- * @param {Function & {interactive: boolean}} [params.askQuestion]
- * @returns {Promise<{domainContext: string|null, stageResult: Object}>}
- */
-export async function runDomainCuratorStage({ config, logger, emitter, eventBase, session, trackBudget, domainHints = [], askQuestion = null }) {
-  logger.setContext?.({ iteration: 0, stage: "domain-curator" });
-
-  emitProgress(
-    emitter,
-    makeEvent("domain-curator:start", { ...eventBase, stage: "domain-curator" }, {
-      message: "Domain Curator discovering domain knowledge",
-      detail: { domainHints, interactive: Boolean(askQuestion?.interactive) }
-    })
-  );
-
-  const start = Date.now();
-  const curator = new DomainCuratorRole({ config, logger });
-
-  let curatorOutput;
-  try {
-    curatorOutput = await curator.execute({
-      task: session.task,
-      domainHints,
-      askQuestion,
-      projectDir: config.projectDir || null
-    });
-  } catch (err) {
-    logger.warn(`Domain Curator threw: ${err.message}`);
-    curatorOutput = {
-      ok: true,
-      result: { selectedDomains: [], domainContext: null, domainsFound: 0, domainsUsed: 0, source: "error" },
-      summary: `Domain Curator error: ${err.message}`
-    };
-  }
-
-  trackBudget({
-    role: "domain-curator",
-    provider: "local",
-    model: null,
-    result: curatorOutput,
-    duration_ms: Date.now() - start
-  });
-
-  const domainContext = curatorOutput.result?.domainContext || null;
-
-  const stageResult = {
-    ok: curatorOutput.ok,
-    domainsFound: curatorOutput.result?.domainsFound || 0,
-    domainsUsed: curatorOutput.result?.domainsUsed || 0,
-    selectedDomains: curatorOutput.result?.selectedDomains || [],
-    source: curatorOutput.result?.source || "none",
-    hasDomainContext: Boolean(domainContext)
-  };
-
-  emitProgress(
-    emitter,
-    makeEvent("domain-curator:done", { ...eventBase, stage: "domain-curator" }, {
-      status: "ok",
-      message: curatorOutput.summary,
-      detail: stageResult
-    })
-  );
-
-  return { domainContext, stageResult };
-}

package/src/orchestrator/stages/format-stage.js

@@ -1,61 +0,0 @@
-/**
- * KJC-TSK-1237 (#2565): no stage formatted the coder's files, so a pre-commit
- * format check aborted the final commit after every gate was green, and a
- * one-command fix reached Solomon. This stage runs the project's formatter in
- * write mode (the one kj harden knows) on the files of this session only:
- * pending now and not pending when the session started. It is not a gate: a
- * failing or missing formatter is said and the next stages judge the files.
- * Opt-out: `development.format_after_coder: false`.
- */
-import { existsSync, readdirSync } from "node:fs";
-import { extname, join } from "node:path";
-import { emitProgress, makeEvent } from "../../utils/events.js";
-import { runCommand } from "../../utils/process.js";
-import { listPendingPaths } from "../../utils/git.js";
-import { detectStackRoots } from "../../harden/stack-roots.js";
-import { formatWriteFor } from "../../harden/hook-commands.js";
-
-const TIMEOUT_MS = 2 * 60 * 1000;
-const primaryLanguage = (projectDir) => detectStackRoots(projectDir)[0]?.language ?? null;
-
-const expand = (projectDir, p) => (p.endsWith("/")
-  ? readdirSync(join(projectDir, p), { recursive: true }).map((f) => join(p, f))
-  : [p]);
-
-/** Files of the session the formatter takes; git names a new directory, so its files are listed. */
-function filesToFormat({ pending, preexisting, extensions, projectDir }) {
-  const before = new Set(preexisting);
-  return pending.filter((p) => !before.has(p) && existsSync(join(projectDir, p)))
-    .flatMap((p) => expand(projectDir, p))
-    .filter((p) => extensions.includes(extname(p)));
-}
-
-/** @returns {Promise<{ran: boolean, ok?: boolean, files?: string[]}>} */
-export async function runFormatStage({ config, logger, emitter, eventBase, session, detectLanguageImpl = primaryLanguage, listPendingImpl = (dir) => listPendingPaths(dir), runImpl = async (...args) => runCommand(...args) }) {
-  if (config?.development?.format_after_coder === false) return { ran: false };
-  const projectDir = config?.projectDir || process.cwd();
-  const formatter = formatWriteFor(detectLanguageImpl(projectDir), projectDir);
-  if (!formatter) return { ran: false };
-  const preexisting = session?.git_preexisting;
-  if (!Array.isArray(preexisting)) {
-    logger?.warn?.("format: no baseline of what was pending when the session started: nothing formatted");
-    return { ran: false };
-  }
-  let files;
-  try {
-    files = filesToFormat({ pending: await listPendingImpl(projectDir), preexisting, extensions: formatter.extensions, projectDir });
-  } catch (err) {
-    logger?.warn?.(`format: the session's files could not be listed (${err.message}): nothing formatted`);
-    return { ran: false };
-  }
-  if (files.length === 0) return { ran: false };
-  const [bin, ...args] = formatter.command.split(" ");
-  const res = await runImpl(bin, [...args, "--", ...files], { cwd: projectDir, timeout: TIMEOUT_MS }).catch(() => ({ exitCode: null }));
-  const ok = res.exitCode === 0;
-  const message = ok
-    ? `format: ${formatter.command} on ${files.length} file(s)`
-    : `format: ${formatter.command} failed (exit ${res.exitCode ?? "none"}); the next stages judge the files as they are`;
-  logger?.[ok ? "info" : "warn"]?.(message);
-  emitProgress(emitter, makeEvent("format:result", { ...eventBase, stage: "format" }, { status: ok ? "ok" : "warn", message, detail: { command: formatter.command, files } }));
-  return { ran: true, ok, files };
-}

package/src/orchestrator/stages/hu-reviewer-phases/detect-and-apply-splits.js

@@ -1,127 +0,0 @@
-/**
- * HU Reviewer phase: detect splittable HUs and apply the split.
- *
- * Extracted from `runHuReviewerStage` in PR-M (audit follow-up,
- * KJC-PCS-0033). Was 78 LOC inlined inside the 311-LOC parent
- * function — moving it brings the stage closer to a clean
- * load → split → evaluate → return shape.
- *
- * For each pending HU in the batch:
- *
- *   1. Run the deterministic indicator detector
- *      (src/hu/splitting-detector.js). If no indicators, skip.
- *   2. Pick the first heuristic that matches; ask the LLM for a
- *      split proposal. Retry with other heuristics on failure.
- *   3. In autonomous mode (askQuestion=null) the proposal is
- *      auto-accepted. In interactive mode the FDE confirms.
- *   4. Replace the original story with the proposed sub-HUs in
- *      the batch and persist.
- *
- * Behaviour identical to the inlined version — only the container
- * changes. The closure variables (batch, askQuestion, config,
- * logger, emitter, eventBase, batchSessionId) become explicit
- * function parameters.
- */
-
-import { saveHuBatch, updateStoryStatus } from "#hu/store.js";
-import { emitProgress, makeEvent } from "#utils/events.js";
-import { detectIndicators, selectHeuristic } from "#hu/splitting-detector.js";
-import { generateSplitProposal, formatSplitProposalForFDE, buildSplitDependencies } from "#hu/splitting-generator.js";
-
-/**
- * Build a fresh sub-HU story object from a proposal entry. Same
- * shape the inlined code produced; centralised to avoid the
- * autonomous + interactive paths drifting apart.
- */
-function buildSubHuStory(sub) {
-  const text = `${sub.title}\n\n${sub.text}\n\nAcceptance Criteria:\n${(sub.acceptanceCriteria || []).map((ac) => `- ${ac}`).join("\n")}`;
-  const now = new Date().toISOString();
-  return {
-    id: sub.id,
-    status: "pending",
-    original: { text },
-    blocked_by: sub.blocked_by || [],
-    certified: null,
-    quality: null,
-    context_requests: [],
-    created_at: now,
-    updated_at: now,
-  };
-}
-
-/**
- * Replace `story` in `batch.stories` with the expanded sub-HUs and
- * emit the `hu-reviewer:split-accepted` event.
- */
-function applySplit({ batch, story, proposal, heuristic, source, eventBase, emitter }) {
-  const updatedSubHUs = buildSplitDependencies(proposal.subHUs, story);
-  const storyIndex = batch.stories.findIndex((s) => s.id === story.id);
-  const newStories = updatedSubHUs.map(buildSubHuStory);
-  batch.stories.splice(storyIndex, 1, ...newStories);
-  emitProgress(emitter, makeEvent("hu-reviewer:split-accepted", { ...eventBase, stage: "hu-reviewer" }, {
-    message: `${source} accepted split of ${story.id} into ${updatedSubHUs.length} sub-HUs`,
-    detail: { originalId: story.id, subHUs: updatedSubHUs.map((s) => s.id), heuristic }
-  }));
-}
-
-/**
- * @param {object} args
- * @param {object} args.batch              — HU batch (mutated in place)
- * @param {string} args.batchSessionId     — for saveHuBatch persistence
- * @param {Function|null} args.askQuestion — interactive prompt (null = auto-accept)
- * @param {object} args.config
- * @param {object} args.logger
- * @param {object} args.emitter
- * @param {object} args.eventBase
- */
-export async function detectAndApplySplits({ batch, batchSessionId, askQuestion, config, logger, emitter, eventBase }) {
-  const storiesToSplit = [...batch.stories].filter((s) => s.status === "pending");
-  for (const story of storiesToSplit) {
-    const indicators = detectIndicators(story.original.text);
-    if (indicators.length === 0) continue;
-
-    let heuristic = selectHeuristic(indicators);
-    if (!heuristic) continue;
-
-    const triedHeuristics = [];
-
-    while (heuristic) {
-      const proposal = await generateSplitProposal(
-        { id: story.id, text: story.original.text },
-        heuristic, config, logger
-      );
-
-      if (!proposal) {
-        triedHeuristics.push(heuristic);
-        heuristic = selectHeuristic(indicators, triedHeuristics);
-        continue;
-      }
-
-      if (!askQuestion) {
-        // Autonomous mode: auto-accept the split.
-        applySplit({ batch, story, proposal, heuristic, source: "Auto", eventBase, emitter });
-      } else {
-        // Interactive mode: ask FDE for confirmation.
-        const formatted = formatSplitProposalForFDE(proposal);
-        const question = `Split proposed for ${story.id}:\n${formatted}\nAccept? (yes/no/try another)`;
-        emitProgress(emitter, makeEvent("hu-reviewer:split-proposal", { ...eventBase, stage: "hu-reviewer" }, {
-          message: `Split proposal for ${story.id} using heuristic: ${heuristic}`,
-          detail: { originalId: story.id, heuristic, subHUCount: proposal.subHUs.length }
-        }));
-        const answer = await askQuestion(question, { iteration: 0, stage: "hu-reviewer" });
-        if (!answer || answer.toLowerCase().startsWith("yes")) {
-          applySplit({ batch, story, proposal, heuristic, source: "FDE", eventBase, emitter });
-        } else if (answer.toLowerCase().includes("try") || answer.toLowerCase().startsWith("no")) {
-          triedHeuristics.push(heuristic);
-          heuristic = selectHeuristic(indicators, triedHeuristics);
-          if (!heuristic) {
-            updateStoryStatus(batch, story.id, "needs_context");
-          }
-          continue;
-        }
-      }
-      break;
-    }
-    await saveHuBatch(batchSessionId, batch);
-  }
-}

package/src/orchestrator/stages/hu-reviewer-stage.js

@@ -1,419 +0,0 @@
-/**
- * HU Reviewer stage logic + splitting logic.
- * Extracted from pre-loop-stages.js for maintainability.
- */
-
-import { DiscoverRole } from "../../roles/discover-role.js";
-import { HuReviewerRole } from "../../roles/hu-reviewer-role.js";
-import { createAgent } from "../../agents/index.js";
-import { addCheckpoint } from "../../session/store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
-import { buildDecompositionPrompt, parseDecompositionOutput, uncoveredCriteria } from "../../prompts/hu-reviewer.js";
-import { criteriaOfCard } from "../../roles/acceptance-coverage-role.js";
-import { huComplexity } from "../../hu/complexity-tier.js";
-import { createStallDetector } from "../../utils/stall-detector.js";
-import { createHuBatch, loadHuBatch, saveHuBatch, updateStoryStatus, updateStoryQuality, updateStoryCertified, addContextRequest, answerContextRequest } from "../../hu/store.js";
-import { topologicalSort } from "../../hu/graph.js";
-import { detectAndApplySplits } from "./hu-reviewer-phases/detect-and-apply-splits.js";
-
-/**
- * Use an AI agent to decompose a complex task into multiple formal HUs.
- * Returns null if decomposition fails or the task is too simple.
- */
-async function decomposeTaskIntoHUs({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
-  const provider = config?.roles?.hu_reviewer?.provider || coderRole.provider;
-  // KJC-TSK-0989 (#1894): the card's criteria go into the decomposition, numbered,
-  // so each one lands in an HU; the ones no HU covers are said and kept, never lost.
-  const criteria = criteriaOfCard(session.pg_card);
-  const prompt = buildDecompositionPrompt(session.task, { criteria });
-
-  emitProgress(
-    emitter,
-    makeEvent("hu-reviewer:decompose-start", { ...eventBase, stage: "hu-reviewer" }, {
-      message: "Decomposing complex task into formal HUs",
-      detail: { provider }
-    })
-  );
-
-  const onOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "hu-reviewer" }, {
-      message: line,
-      detail: { stream, agent: provider }
-    }));
-  };
-  const stall = createStallDetector({
-    onOutput, emitter, eventBase, stage: "hu-reviewer", provider
-  });
-
-  const agent = createAgent(provider, config, logger);
-  const decompStart = Date.now();
-  let result;
-  try {
-    result = await agent.runTask({ prompt, role: "hu-reviewer", onOutput: stall.onOutput });
-  } catch (err) {
-    logger.warn(`HU decomposition threw: ${err.message}`);
-    return null;
-  } finally {
-    stall.stop();
-  }
-
-  trackBudget({
-    role: "hu-reviewer-decompose",
-    provider,
-    model: config?.roles?.hu_reviewer?.model || coderRole.model,
-    result,
-    duration_ms: Date.now() - decompStart
-  });
-
-  if (!result.ok) {
-    logger.warn(`HU decomposition failed: ${result.error || "unknown"}`);
-    return null;
-  }
-
-  const stories = parseDecompositionOutput(result.output);
-  if (!stories || stories.length < 2) {
-    logger.info("HU decomposition returned < 2 stories, falling back to single auto-story");
-    return null;
-  }
-  const uncovered = uncoveredCriteria(stories, criteria);
-  if (uncovered.length > 0) {
-    const last = stories.at(-1);
-    const tags = uncovered.map((c) => `[AC-${c.index}]`);
-    last.acceptanceCriteria.push(...uncovered.map((c, i) => `${tags[i]} ${c.text}`));
-    last.covers.push(...uncovered.map((c) => c.index));
-    logger.warn(`HU decomposition left ${uncovered.length} card criteria with no HU; added to ${last.id}: ${tags.join(" ")}`);
-    emitProgress(emitter, makeEvent("hu-reviewer:criteria-uncovered", { ...eventBase, stage: "hu-reviewer" }, {
-      status: "warn",
-      message: `${uncovered.length} card criteria had no HU and were added to ${last.id}`,
-      detail: { uncovered, addedTo: last.id }
-    }));
-  }
-
-  // KJC-TSK-0698 (MR-A): each HU's tier and why, from this same answer plus the deterministic signal.
-  for (const story of stories) {
-    story.complexity = huComplexity(story);
-    logger.info(`${story.id} tier ${story.complexity.tier}: ${story.complexity.reason}`);
-  }
-
-  emitProgress(
-    emitter,
-    makeEvent("hu-reviewer:decompose-end", { ...eventBase, stage: "hu-reviewer" }, {
-      message: `Task decomposed into ${stories.length} HUs`,
-      detail: { count: stories.length, ids: stories.map(s => s.id), tiers: Object.fromEntries(stories.map((s) => [s.id, s.complexity])) }
-    })
-  );
-
-  return stories;
-}
-
-export async function runDiscoverStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
-  logger.setContext({ iteration: 0, stage: "discover" });
-  const discoverProvider = config?.roles?.discover?.provider || coderRole.provider;
-  emitProgress(
-    emitter,
-    makeEvent("discover:start", { ...eventBase, stage: "discover" }, {
-      message: "Discover analyzing task for gaps",
-      detail: { discover: discoverProvider, provider: discoverProvider, executorType: "agent" }
-    })
-  );
-  const discoverOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "discover" }, {
-      message: line,
-      detail: { stream, agent: discoverProvider }
-    }));
-  };
-  const discoverStall = createStallDetector({
-    onOutput: discoverOnOutput, emitter, eventBase, stage: "discover", provider: discoverProvider
-  });
-
-  const mode = config?.pipeline?.discover?.mode || "gaps";
-  const discover = new DiscoverRole({ config, logger, emitter });
-  await discover.init({ task: session.task, sessionId: session.id, iteration: 0 });
-  const discoverStart = Date.now();
-  let discoverOutput;
-  try {
-    discoverOutput = await discover.run({ task: session.task, mode, onOutput: discoverStall.onOutput });
-  } catch (err) {
-    logger.warn(`Discover threw: ${err.message}`);
-    discoverOutput = { ok: false, summary: `Discover error: ${err.message}`, result: { error: err.message } };
-  } finally {
-    discoverStall.stop();
-  }
-  trackBudget({
-    role: "discover",
-    provider: discoverProvider,
-    model: config?.roles?.discover?.model || coderRole.model,
-    result: discoverOutput,
-    duration_ms: Date.now() - discoverStart
-  });
-
-  await addCheckpoint(session, {
-    stage: "discover",
-    iteration: 0,
-    ok: discoverOutput.ok,
-    provider: discoverProvider,
-    model: config?.roles?.discover?.model || coderRole.model || null
-  });
-
-  const stageResult = {
-    ok: discoverOutput.ok,
-    verdict: discoverOutput.result?.verdict || null,
-    gaps: discoverOutput.result?.gaps || [],
-    mode
-  };
-
-  emitProgress(
-    emitter,
-    makeEvent("discover:end", { ...eventBase, stage: "discover" }, {
-      status: discoverOutput.ok ? "ok" : "fail",
-      message: discoverOutput.ok ? "Discovery completed" : `Discovery failed: ${discoverOutput.summary}`,
-      detail: { ...stageResult, provider: discoverProvider, executorType: "agent" }
-    })
-  );
-
-  return { stageResult };
-}
-
-/**
- * Run the HU Reviewer stage: load stories from YAML or generate from task, evaluate, certify, and return in topological order.
- */
-export async function runHuReviewerStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, huFile, askQuestion, pgStories = null }) {
-  logger.setContext({ iteration: 0, stage: "hu-reviewer" });
-  const huReviewerProvider = config?.roles?.hu_reviewer?.provider || coderRole.provider;
-  emitProgress(
-    emitter,
-    makeEvent("hu-reviewer:start", { ...eventBase, stage: "hu-reviewer" }, {
-      message: "HU Reviewer certifying user stories",
-      detail: { provider: huReviewerProvider, executorType: "agent" }
-    })
-  );
-
-  let stories;
-
-  if (huFile) {
-    // --- Load YAML file ---
-    const yaml = await import("js-yaml");
-    const fs = await import("node:fs/promises");
-    let rawYaml;
-    try {
-      rawYaml = await fs.readFile(huFile, "utf8");
-    } catch (err) {
-      const stageResult = { ok: false, error: `Could not read HU file: ${err.message}` };
-      emitProgress(emitter, makeEvent("hu-reviewer:end", { ...eventBase, stage: "hu-reviewer" }, {
-        status: "fail", message: stageResult.error
-      }));
-      return { stageResult };
-    }
-
-    try {
-      const parsed = yaml.load(rawYaml);
-      stories = Array.isArray(parsed) ? parsed : (parsed?.stories || []);
-    } catch (err) {
-      const stageResult = { ok: false, error: `Invalid YAML in HU file: ${err.message}` };
-      emitProgress(emitter, makeEvent("hu-reviewer:end", { ...eventBase, stage: "hu-reviewer" }, {
-        status: "fail", message: stageResult.error
-      }));
-      return { stageResult };
-    }
-  } else if (pgStories && pgStories.length > 0) {
-    // --- Use pre-built stories from Planning Game card structured data ---
-    stories = pgStories;
-    logger.info(`HU Reviewer: using ${pgStories.length} story(ies) from PG card`);
-    emitProgress(emitter, makeEvent("hu-reviewer:pg-feed", { ...eventBase, stage: "hu-reviewer" }, {
-      message: `Using ${pgStories.length} story(ies) from Planning Game card`,
-      detail: { source: "pg-card", storyIds: pgStories.map(s => s.id) }
-    }));
-  } else {
-    // --- Decompose task into formal HUs via AI, or fall back to single auto-story ---
-    const decomposed = await decomposeTaskIntoHUs({
-      config, logger, emitter, eventBase, session, coderRole, trackBudget
-    });
-    if (decomposed && decomposed.length > 1) {
-      stories = decomposed.map((hu, idx) => {
-        const isFirst = idx === 0;
-        const fullText = `As a ${hu.role}, I want to ${hu.goal}, so that ${hu.benefit}\n\nTitle: ${hu.title}\nAcceptance Criteria:\n${hu.acceptanceCriteria.map(ac => `- ${ac}`).join("\n")}`;
-        const skeletonText = `As a ${hu.role}, I want to ${hu.goal}, so that ${hu.benefit}\n\nTitle: ${hu.title}`;
-        return {
-          id: hu.id,
-          text: isFirst ? fullText : skeletonText,
-          blocked_by: hu.dependsOn || [],
-          needsRefinement: !isFirst,
-          complexity: hu.complexity
-        };
-      });
-    } else {
-      stories = [{ id: "HU-AUTO-001", text: session.task }];
-    }
-  }
-
-  if (stories.length === 0) {
-    const stageResult = { ok: true, certified: 0, stories: [] };
-    emitProgress(emitter, makeEvent("hu-reviewer:end", { ...eventBase, stage: "hu-reviewer" }, {
-      status: "ok", message: "No stories to evaluate"
-    }));
-    return { stageResult };
-  }
-
-  // --- Create or load batch ---
-  const batchSessionId = `hu-${session.id}`;
-  let batch;
-  try {
-    batch = await loadHuBatch(batchSessionId);
-  } catch { /* no existing batch */
-    batch = await createHuBatch(batchSessionId, stories);
-  }
-
-  // --- Splitting detection: extracted to hu-reviewer-phases/detect-and-apply-splits.js (PR-M) ---
-  await detectAndApplySplits({
-    batch, batchSessionId, askQuestion, config, logger, emitter, eventBase,
-  });
-
-
-  // --- Evaluate loop (re-evaluate entire batch until all certified or needs_context with no askQuestion) ---
-  const huReviewerOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "hu-reviewer" }, {
-      message: line,
-      detail: { stream, agent: huReviewerProvider }
-    }));
-  };
-
-  let maxRounds = 5;
-  let round = 0;
-
-  while (round < maxRounds) {
-    round += 1;
-
-    const pendingStories = batch.stories.filter(s => s.status === "pending" || s.status === "needs_context");
-    if (pendingStories.length === 0) break;
-
-    const storiesToEvaluate = pendingStories.map(s => ({ id: s.id, text: s.original.text }));
-
-    const stall = createStallDetector({
-      onOutput: huReviewerOnOutput, emitter, eventBase, stage: "hu-reviewer", provider: huReviewerProvider
-    });
-
-    const huReviewer = new HuReviewerRole({ config, logger, emitter, createAgentFn: createAgent });
-    await huReviewer.init({ task: session.task, sessionId: session.id, iteration: 0 });
-    const reviewStart = Date.now();
-    let reviewOutput;
-    try {
-      reviewOutput = await huReviewer.run({ stories: storiesToEvaluate, onOutput: stall.onOutput });
-    } catch (err) {
-      logger.warn(`HU Reviewer threw: ${err.message}`);
-      reviewOutput = { ok: false, summary: `HU Reviewer error: ${err.message}`, result: { error: err.message } };
-    } finally {
-      stall.stop();
-    }
-
-    trackBudget({
-      role: "hu-reviewer",
-      provider: huReviewerProvider,
-      model: config?.roles?.hu_reviewer?.model || coderRole.model,
-      result: reviewOutput,
-      duration_ms: Date.now() - reviewStart
-    });
-
-    if (!reviewOutput.ok || !reviewOutput.result?.evaluations) {
-      break;
-    }
-
-    // --- Process evaluations ---
-    for (const evaluation of reviewOutput.result.evaluations) {
-      const storyId = evaluation.story_id;
-      try {
-        updateStoryQuality(batch, storyId, evaluation.scores);
-      } catch {
-        continue; // story not found in batch, skip
-      }
-
-      if (evaluation.verdict === "certified") {
-        updateStoryCertified(batch, storyId, evaluation.certified_hu);
-      } else if (evaluation.verdict === "needs_context" && evaluation.context_needed) {
-        addContextRequest(batch, storyId, {
-          fields_needed: evaluation.context_needed.fields_needed || [],
-          question: evaluation.context_needed.question_to_fde || ""
-        });
-      } else if (evaluation.verdict === "needs_rewrite" && evaluation.rewritten) {
-        // Accept the rewrite and re-certify
-        updateStoryCertified(batch, storyId, evaluation.rewritten);
-      } else {
-        updateStoryStatus(batch, storyId, "pending");
-      }
-    }
-
-    await saveHuBatch(batchSessionId, batch);
-
-    // --- Check if any need context ---
-    const needsContext = batch.stories.filter(s => s.status === "needs_context");
-    if (needsContext.length > 0) {
-      const consolidatedQuestions = reviewOutput.result.batch_summary?.consolidated_questions
-        || needsContext.map(s => {
-          const pending = s.context_requests.find(r => !r.answered_at);
-          return pending ? `[${s.id}] ${pending.question_to_fde}` : null;
-        }).filter(Boolean).join("\n");
-
-      if (!askQuestion) {
-        // No interactive input — pause session
-        break;
-      }
-
-      emitProgress(emitter, makeEvent("hu-reviewer:needs-context", { ...eventBase, stage: "hu-reviewer" }, {
-        message: `${needsContext.length} story(ies) need context from FDE`,
-        detail: { questions: consolidatedQuestions }
-      }));
-
-      const answer = await askQuestion(
-        `The HU Reviewer needs additional context:\n\n${consolidatedQuestions}\n\nPlease provide your answers:`,
-        { iteration: 0, stage: "hu-reviewer" }
-      );
-
-      if (!answer) break;
-
-      // --- Incorporate FDE answers and re-evaluate ---
-      for (const s of needsContext) {
-        answerContextRequest(batch, s.id, answer);
-      }
-      await saveHuBatch(batchSessionId, batch);
-      // Loop will re-evaluate entire batch
-    }
-  }
-
-  await addCheckpoint(session, {
-    stage: "hu-reviewer",
-    iteration: 0,
-    ok: true,
-    certified: batch.stories.filter(s => s.status === "certified").length,
-    total: batch.stories.length
-  });
-
-  // --- Return certified stories in topological order ---
-  const certifiedStories = batch.stories.filter(s => s.status === "certified");
-  let orderedIds;
-  try {
-    orderedIds = topologicalSort(certifiedStories);
-  } catch { /* cyclic dependency */
-    orderedIds = certifiedStories.map(s => s.id);
-  }
-
-  const orderedStories = orderedIds.map(id => batch.stories.find(s => s.id === id)).filter(Boolean);
-
-  const stageResult = {
-    ok: true,
-    certified: certifiedStories.length,
-    total: batch.stories.length,
-    needsContext: batch.stories.filter(s => s.status === "needs_context").length,
-    stories: orderedStories,
-    batchSessionId
-  };
-
-  emitProgress(
-    emitter,
-    makeEvent("hu-reviewer:end", { ...eventBase, stage: "hu-reviewer" }, {
-      status: "ok",
-      message: `HU Review complete: ${certifiedStories.length}/${batch.stories.length} certified`,
-      detail: { ...stageResult, provider: huReviewerProvider, executorType: "agent" }
-    })
-  );
-
-  return { stageResult };
-}