karajan-code 4.70.4 → 5.0.1

package/src/orchestrator/repair/repair-runner.js

@@ -1,142 +0,0 @@
-/**
- * Repair runner — orchestrates the Repairer role end-to-end.
- *
- * Called from run-hu-batch when an acceptance test failure has been
- * classified as `infeasible` by repair-detector. The runner:
- *   1. Builds the prompt context (failing test, error output, HU
- *      intent, sibling tests).
- *   2. Invokes RepairerRole.
- *   3. If verdict=fixable: patches the plan JSON's acceptance_tests
- *      AND the in-memory batch story so the next coder iteration sees
- *      the corrected test. Saves both. Returns { repaired: true }.
- *   4. If verdict=unfixable: returns { repaired: false, escalate: true,
- *      reason } so the caller can hand off to Solomon / FDE.
- *   5. If RepairerRole itself fails (agent error): returns
- *      { repaired: false, escalate: false, error } so the caller
- *      decides whether to retry coder or escalate.
- */
-
-import { RepairerRole } from "../../roles/repairer-role.js";
-import { saveHuBatch } from "../../hu/store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
-
-/**
- * @param {object} args
- * @param {object} args.story       — the HU story object (in-memory batch slice). MUTATED.
- * @param {number} args.testIndex   — index in story.acceptance_tests of the failing test.
- * @param {string} args.errorOutput — last failing run's stderr+stdout.
- * @param {string} args.batchSessionId
- * @param {object} args.batch       — full batch object. MUTATED (story is a slice).
- * @param {object} args.config
- * @param {object} args.logger
- * @param {object} args.emitter
- * @param {object} args.eventBase
- * @param {string} args.failureKind — repair-detector's `kind` (e.g. "jq-as-binding-misuse").
- * @param {Function} [args.savePlanPatch] — async (huId, fieldPatch) => void; if provided,
- *                                          patches the plan JSON on disk too.
- * @returns {Promise<{repaired: boolean, escalate?: boolean, reason?: string, error?: string}>}
- */
-export async function runRepair({
-  story, testIndex, errorOutput, batchSessionId, batch,
-  config, logger, emitter, eventBase, failureKind, savePlanPatch,
-}) {
-  if (!story || !Array.isArray(story.acceptance_tests) || !story.acceptance_tests[testIndex]) {
-    return { repaired: false, escalate: false, error: "repair-runner: invalid story or testIndex" };
-  }
-
-  const failingTest = story.acceptance_tests[testIndex];
-  const siblingTests = story.acceptance_tests.filter((_, i) => i !== testIndex);
-
-  emitProgress(emitter, makeEvent("repair:start", { ...eventBase, stage: "repair" }, {
-    message: `Repairer invoked for HU ${story.id} test #${testIndex} (kind=${failureKind})`,
-    detail: {
-      huId: story.id,
-      testIndex,
-      testContent: typeof failingTest === "object" ? failingTest.content : failingTest,
-      kind: failureKind,
-    },
-  }));
-
-  const repairer = new RepairerRole({ config, logger, emitter });
-  await repairer.init({ task: story.scope || story.title || story.id, sessionId: batchSessionId, iteration: 0 });
-
-  let result;
-  try {
-    result = await repairer.run({
-      failingTest,
-      errorOutput,
-      huTitle: story.title || story.id,
-      huScope: story.scope || "",
-      siblingTests,
-      iteration: 0,
-    });
-  } catch (err) {
-    logger.warn(`Repairer threw: ${err.message}`);
-    emitProgress(emitter, makeEvent("repair:end", { ...eventBase, stage: "repair" }, {
-      status: "fail",
-      message: `Repairer error: ${err.message}`,
-      detail: { huId: story.id, testIndex },
-    }));
-    return { repaired: false, escalate: false, error: err.message };
-  }
-
-  if (!result?.ok) {
-    logger.warn(`Repairer failed: ${result?.summary || "unknown"}`);
-    emitProgress(emitter, makeEvent("repair:end", { ...eventBase, stage: "repair" }, {
-      status: "fail",
-      message: `Repairer could not produce a verdict: ${result?.summary || "unknown"}`,
-      detail: { huId: story.id, testIndex },
-    }));
-    return { repaired: false, escalate: false, error: result?.summary || "no verdict" };
-  }
-
-  const { verdict, fixed_test: fixedTest, reason } = result.result;
-
-  if (verdict === "unfixable") {
-    logger.info(`Repairer: HU ${story.id} test #${testIndex} unfixable — ${reason}`);
-    emitProgress(emitter, makeEvent("repair:end", { ...eventBase, stage: "repair" }, {
-      status: "escalate",
-      message: `Repairer: unfixable — ${reason}`,
-      detail: { huId: story.id, testIndex, reason },
-    }));
-    return { repaired: false, escalate: true, reason };
-  }
-
-  if (verdict !== "fixable" || !fixedTest) {
-    logger.warn(`Repairer returned unexpected verdict: ${verdict}`);
-    return { repaired: false, escalate: false, error: `unexpected verdict: ${verdict}` };
-  }
-
-  // Apply the fix in-memory and persist when we have the batch handle.
-  // Some callers can't pass `batch` from their scope (closure depth);
-  // the in-memory mutation of `story.acceptance_tests` is enough for
-  // the next iteration of the same HU loop because every acceptance
-  // run reads the live story object. Disk persistence is a "next run
-  // sees the fix too" optimisation; PR #544's reconcile keeps the
-  // plan JSON consistent across runs in either case.
-  story.acceptance_tests[testIndex] = fixedTest;
-  if (batch && batchSessionId) {
-    await saveHuBatch(batchSessionId, batch);
-  }
-
-  if (typeof savePlanPatch === "function") {
-    try {
-      await savePlanPatch(story.id, { acceptance_tests: story.acceptance_tests });
-    } catch (err) {
-      logger.warn(`Repairer: in-memory + batch fixed but plan-patch failed: ${err.message}`);
-    }
-  }
-
-  logger.info(`Repairer: HU ${story.id} test #${testIndex} REPAIRED — ${reason}`);
-  emitProgress(emitter, makeEvent("repair:end", { ...eventBase, stage: "repair" }, {
-    status: "ok",
-    message: `Repairer fixed HU ${story.id} test #${testIndex}: ${reason}`,
-    detail: {
-      huId: story.id,
-      testIndex,
-      reason,
-      fixedContent: typeof fixedTest === "object" ? fixedTest.content : fixedTest,
-    },
-  }));
-  return { repaired: true, reason };
-}

package/src/orchestrator/reviewer-fallback.js

@@ -1,45 +0,0 @@
-import { ReviewerRole } from "../roles/reviewer-role.js";
-import { createAgent } from "../agents/index.js";
-import { addCheckpoint } from "../session/store.js";
-
-export async function runReviewerWithFallback({ reviewerName, config, logger, emitter, reviewInput, session, iteration, onAttemptResult }) {
-  const fallbackReviewer = config.reviewer_options?.fallback_reviewer;
-  const retries = Math.max(0, Number(config.reviewer_options?.retries ?? 1));
-  const candidates = [reviewerName];
-  if (fallbackReviewer && fallbackReviewer !== reviewerName) {
-    candidates.push(fallbackReviewer);
-  }
-
-  const attempts = [];
-  for (const name of candidates) {
-    const reviewerConfig = { ...config, roles: { ...config.roles, reviewer: { ...config.roles?.reviewer, provider: name } } };
-    const role = new ReviewerRole({ config: reviewerConfig, logger, emitter, createAgentFn: createAgent });
-    await role.init();
-    for (let attempt = 1; attempt <= retries + 1; attempt += 1) {
-      let execResult;
-      try {
-        execResult = await role.execute(reviewInput);
-      } catch (err) {
-        logger.warn(`Reviewer ${name} attempt ${attempt} threw: ${err.message}`);
-        execResult = { ok: false, result: { error: err.message }, summary: `Reviewer error: ${err.message}` };
-      }
-      if (onAttemptResult) {
-        await onAttemptResult({ reviewer: name, result: execResult.result });
-      }
-      attempts.push({ reviewer: name, attempt, ok: execResult.ok, result: execResult.result, execResult });
-      await addCheckpoint(session, {
-        stage: "reviewer-attempt",
-        iteration,
-        reviewer: name,
-        attempt,
-        ok: execResult.ok
-      });
-
-      if (execResult.ok) {
-        return { execResult, attempts };
-      }
-    }
-  }
-
-  return { execResult: null, attempts };
-}

package/src/orchestrator/role-output-compressor.js

@@ -1,189 +0,0 @@
-// Compress role outputs before passing as context to the next role.
-// Reduces token usage by extracting essentials and dropping verbose explanations.
-
-/**
- * Compression strategies per role output type.
- */
-const COMPRESSORS = {
-  researcher: compressResearcher,
-  architect: compressArchitect,
-  planner: compressPlanner,
-  reviewer: compressReviewer,
-  tester: compressTester,
-  security: compressSecurity,
-  sonar: compressSonar,
-  default: compressDefault
-};
-
-/**
- * Extract essentials from researcher output.
- */
-function compressResearcher(output) {
-  if (!output || typeof output !== "object") return output;
-  const parts = [];
-  if (output.affected_files?.length) parts.push(`Files: ${output.affected_files.join(", ")}`);
-  if (output.patterns?.length) parts.push(`Patterns: ${output.patterns.join(", ")}`);
-  if (output.risks?.length) parts.push(`Risks: ${output.risks.join(", ")}`);
-  if (output.constraints?.length) parts.push(`Constraints: ${output.constraints.join(", ")}`);
-  return parts.join("\n");
-}
-
-/**
- * Extract essentials from architect output.
- */
-function compressArchitect(output) {
-  if (!output || typeof output !== "object") return output;
-  const arch = output.architecture || output;
-  const parts = [];
-  if (arch.type) parts.push(`Type: ${arch.type}`);
-  if (arch.layers?.length) parts.push(`Layers: ${arch.layers.join(" → ")}`);
-  if (arch.patterns?.length) parts.push(`Patterns: ${arch.patterns.join(", ")}`);
-  const entities = arch.dataModel?.entities;
-  if (entities?.length) {
-    const names = entities.map(e => typeof e === "string" ? e : e.name).filter(Boolean);
-    if (names.length) parts.push(`Entities: ${names.join(", ")}`);
-  }
-  if (output.verdict) parts.push(`Verdict: ${output.verdict}`);
-  return parts.join("\n");
-}
-
-/**
- * Extract essentials from planner output — keep numbered steps only.
- */
-function compressPlanner(output) {
-  if (!output || typeof output !== "object") return output;
-  const plan = output.plan || output;
-  if (typeof plan !== "string") return JSON.stringify(plan);
-
-  // Keep only numbered steps, drop prose
-  const lines = plan.split("\n").filter(l => l.trim());
-  const steps = lines.filter(l => /^\s*\d+[.)]\s/.test(l) || /^\s*[-*]\s/.test(l));
-  if (steps.length >= 3) return steps.join("\n");
-  return plan.slice(0, 1500);
-}
-
-/**
- * Compress reviewer output — drop non-blocking suggestions, keep blocking.
- */
-function compressReviewer(output) {
-  if (!output || typeof output !== "object") return output;
-  const blocking = output.blocking_issues || [];
-  if (!blocking.length) return `Approved${output.summary ? `: ${output.summary.slice(0, 200)}` : ""}`;
-
-  const items = blocking.map((x, i) => {
-    const sev = x.severity ? `[${x.severity}]` : "";
-    const loc = x.file ? ` (${x.file}${x.line ? `:${x.line}` : ""})` : "";
-    return `${i + 1}. ${sev}${loc} ${x.description || "no description"}${x.suggested_fix ? ` — Fix: ${x.suggested_fix}` : ""}`;
-  });
-  return `Rejected (${blocking.length} blocking):\n${items.join("\n")}`;
-}
-
-/**
- * Compress tester output — keep verdict + coverage + missing scenarios.
- */
-function compressTester(output) {
-  if (!output || typeof output !== "object") return output;
-  const parts = [];
-  parts.push(`Verdict: ${output.verdict || "unknown"}`);
-  if (output.coverage?.overall != null) parts.push(`Coverage: ${output.coverage.overall}%`);
-  if (output.missing_scenarios?.length) {
-    parts.push(`Missing: ${output.missing_scenarios.slice(0, 5).join("; ")}`);
-  }
-  if (output.quality_issues?.length) {
-    parts.push(`Quality: ${output.quality_issues.slice(0, 3).join("; ")}`);
-  }
-  return parts.join("\n");
-}
-
-/**
- * Compress security output — keep verdict + grouped vulnerabilities.
- */
-function compressSecurity(output) {
-  if (!output || typeof output !== "object") return output;
-  const vulns = output.vulnerabilities || [];
-  if (vulns.length === 0) return `Verdict: ${output.verdict || "pass"}; no vulnerabilities`;
-
-  const bySev = {};
-  for (const v of vulns) {
-    const sev = v.severity || "unknown";
-    bySev[sev] = bySev[sev] || [];
-    bySev[sev].push(`${v.file || "?"}${v.line ? `:${v.line}` : ""} ${v.description}`);
-  }
-
-  const sevOrder = ["critical", "high", "medium", "low"];
-  const lines = [`Verdict: ${output.verdict || "fail"}`];
-  for (const sev of sevOrder) {
-    if (bySev[sev]?.length) lines.push(`${sev}: ${bySev[sev].slice(0, 3).join("; ")}`);
-  }
-  return lines.join("\n");
-}
-
-/**
- * Compress sonar output — keep gate status + top issues.
- */
-function compressSonar(output) {
-  if (!output || typeof output !== "object") return output;
-  const parts = [];
-  if (output.gateStatus) parts.push(`Gate: ${output.gateStatus}`);
-  if (output.issues?.length) {
-    parts.push(`${output.issues.length} issue(s)`);
-    const top = output.issues.slice(0, 5).map(i => `${i.severity}: ${i.message}`);
-    parts.push(top.join("; "));
-  }
-  return parts.join("\n");
-}
-
-/**
- * Default compression: truncate long strings, drop noise.
- */
-function compressDefault(output) {
-  if (!output) return "";
-  if (typeof output === "string") {
-    return output.length > 2000 ? output.slice(0, 2000) + "...[truncated]" : output;
-  }
-  if (typeof output === "object") {
-    const str = JSON.stringify(output, null, 2);
-    return str.length > 2000 ? str.slice(0, 2000) + "...[truncated]" : str;
-  }
-  return String(output);
-}
-
-/**
- * Compress a role output.
- * @param {string} roleName - e.g. "researcher", "reviewer"
- * @param {*} output - role's result object
- * @returns {string} compressed text
- */
-export function compressRoleOutput(roleName, output) {
-  const compressor = COMPRESSORS[roleName] || COMPRESSORS.default;
-  try {
-    return compressor(output);
-  } catch {
-    return COMPRESSORS.default(output);
-  }
-}
-
-/**
- * Estimate token count for a compressed string (rough: chars/4).
- */
-export function estimateTokens(text) {
-  if (!text) return 0;
-  return Math.ceil(String(text).length / 4);
-}
-
-/**
- * Measure compression ratio.
- */
-export function measureCompression(original, compressed) {
-  const origTokens = estimateTokens(typeof original === "string" ? original : JSON.stringify(original));
-  const compTokens = estimateTokens(compressed);
-  const saved = origTokens - compTokens;
-  const ratio = origTokens > 0 ? saved / origTokens : 0;
-  return {
-    originalTokens: origTokens,
-    compressedTokens: compTokens,
-    savedTokens: saved,
-    savedPct: Number((ratio * 100).toFixed(1))
-  };
-}
-

package/src/orchestrator/session-journal.js

@@ -1,308 +0,0 @@
-// Session Journal: persists structured stage outputs and generates summaries.
-// Creates .reviews/session_*/ directories containing markdown files per stage.
-import fs from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Create the journal directory for a session.
- * @param {string} reportDir -base directory (e.g. ".reviews")
- * @param {string} sessionId
- * @returns {Promise<string>} absolute path to the journal directory
- */
-export async function createJournalDir(reportDir, sessionId) {
-  const journalDir = path.resolve(reportDir, sessionId);
-  await fs.mkdir(journalDir, { recursive: true });
-  return journalDir;
-}
-
-/**
- * Write a markdown file to the journal directory.
- * Only writes if content is non-empty. Skips silently otherwise.
- */
-async function writeJournalFile(journalDir, filename, content) {
-  if (!content || !journalDir) return;
-  const filePath = path.join(journalDir, filename);
-  await fs.writeFile(filePath, content, "utf8");
-}
-
-// ── Stage serializers ────────────────────────────────────────────────────────
-
-function serializeDiscovery(stageResult) {
-  if (!stageResult) return null;
-  const lines = ["# Discovery\n"];
-  lines.push(`**Verdict**: ${stageResult.verdict || "N/A"}`);
-  lines.push(`**Mode**: ${stageResult.mode || "gaps"}\n`);
-
-  const gaps = stageResult.gaps || [];
-  if (gaps.length) {
-    lines.push("## Gaps Found\n");
-    for (const gap of gaps) {
-      const severity = gap.severity ? ` [${gap.severity}]` : "";
-      lines.push(`- ${gap.title || gap.description || gap}${severity}`);
-    }
-  }
-
-  if (stageResult.momTestQuestions?.length) {
-    lines.push("\n## Mom Test Questions\n");
-    for (const q of stageResult.momTestQuestions) lines.push(`- ${q}`);
-  }
-  if (stageResult.wendelChecklist?.length) {
-    lines.push("\n## Wendel Checklist\n");
-    for (const item of stageResult.wendelChecklist) lines.push(`- [${item.status}] ${item.condition}`);
-  }
-
-  return lines.join("\n");
-}
-
-function serializeResearch(stageResult) {
-  if (!stageResult) return null;
-  const lines = ["# Research\n"];
-
-  const sections = [
-    { key: "affected_files", title: "Affected Files" },
-    { key: "patterns", title: "Patterns" },
-    { key: "constraints", title: "Constraints" },
-    { key: "risks", title: "Risks" },
-    { key: "prior_decisions", title: "Prior Decisions" }
-  ];
-
-  for (const { key, title } of sections) {
-    const items = stageResult[key];
-    if (items?.length) {
-      lines.push(`## ${title}\n`);
-      for (const item of items) lines.push(`- ${item}`);
-      lines.push("");
-    }
-  }
-
-  if (stageResult.test_coverage) {
-    lines.push(`## Test Coverage\n\n${stageResult.test_coverage}`);
-  }
-
-  return lines.join("\n");
-}
-
-function serializeArchitecture(stageResult) {
-  if (!stageResult) return null;
-  const lines = ["# Architecture\n"];
-  lines.push(`**Verdict**: ${stageResult.verdict || "N/A"}\n`);
-
-  const arch = stageResult.architecture || {};
-  if (arch.type) lines.push(`**Type**: ${arch.type}\n`);
-  if (arch.layers?.length) {
-    lines.push("## Layers\n");
-    for (const l of arch.layers) lines.push(`- ${l}`);
-    lines.push("");
-  }
-  if (arch.patterns?.length) {
-    lines.push("## Patterns\n");
-    for (const p of arch.patterns) lines.push(`- ${p}`);
-    lines.push("");
-  }
-  if (arch.dataModel?.entities?.length) {
-    lines.push("## Data Model\n");
-    for (const e of arch.dataModel.entities) lines.push(`- ${typeof e === "string" ? e : e.name || JSON.stringify(e)}`);
-    lines.push("");
-  }
-  if (arch.apiContracts?.length) {
-    lines.push("## API Contracts\n");
-    for (const a of arch.apiContracts) lines.push(`- ${typeof a === "string" ? a : JSON.stringify(a)}`);
-    lines.push("");
-  }
-  if (arch.tradeoffs?.length) {
-    lines.push("## Tradeoffs\n");
-    for (const t of arch.tradeoffs) lines.push(`- ${t}`);
-  }
-  if (stageResult.questions?.length) {
-    lines.push("\n## Open Questions\n");
-    for (const q of stageResult.questions) lines.push(`- ${q}`);
-  }
-
-  return lines.join("\n");
-}
-
-function serializePlan(stageResult) {
-  if (!stageResult?.plan) return null;
-  return `# Implementation Plan\n\n${stageResult.plan}`;
-}
-
-function serializeTriage(stageResult) {
-  if (!stageResult) return null;
-  const lines = ["# Triage\n"];
-  lines.push(`**Level**: ${stageResult.level || "N/A"}`);
-  lines.push(`**Task Type**: ${stageResult.taskType || "N/A"}`);
-  lines.push(`**Roles**: ${(stageResult.roles || []).join(", ") || "none"}`);
-  if (stageResult.reasoning) lines.push(`\n**Reasoning**: ${stageResult.reasoning}`);
-  if (stageResult.shouldDecompose) {
-    lines.push("\n## Decomposition\n");
-    for (const sub of stageResult.subtasks || []) lines.push(`- ${sub}`);
-  }
-  return lines.join("\n");
-}
-
-// ── Iteration log ────────────────────────────────────────────────────────────
-
-/**
- * Append one iteration entry to the iterations buffer.
- * Called after each iteration completes.
- */
-export function formatIteration({ iteration, coderSummary, reviewerSummary, sonarSummary, solomonRuling, testerSummary, securitySummary, durationMs }) {
-  const lines = [`## Iteration ${iteration}\n`];
-  lines.push(`**Duration**: ${Math.round((durationMs || 0) / 1000)}s\n`);
-
-  if (coderSummary) lines.push(`**Coder**: ${coderSummary}`);
-  if (reviewerSummary) lines.push(`**Reviewer**: ${reviewerSummary}`);
-  if (sonarSummary) lines.push(`**Sonar**: ${sonarSummary}`);
-  if (testerSummary) lines.push(`**Tester**: ${testerSummary}`);
-  if (securitySummary) lines.push(`**Security**: ${securitySummary}`);
-  if (solomonRuling) lines.push(`**Solomon**: ${solomonRuling}`);
-
-  lines.push("");
-  return lines.join("\n");
-}
-
-// ── Decisions log ────────────────────────────────────────────────────────────
-
-export function formatDecision({ timestamp, trigger, context, action, reasoning }) {
-  const lines = [`## ${timestamp || new Date().toISOString()}\n`];
-  lines.push(`**Trigger**: ${trigger}`);
-  if (context) lines.push(`**Context**: ${context}`);
-  lines.push(`**Action**: ${action}`);
-  if (reasoning) lines.push(`**Reasoning**: ${reasoning}`);
-  lines.push("");
-  return lines.join("\n");
-}
-
-// ── Summary ──────────────────────────────────────────────────────────────────
-
-export function generateSummary({ task, result, sessionId, iterations, durationMs, budget, stages, commits, files }) {
-  const lines = ["# Session Summary\n"];
-  lines.push(`**Session**: ${sessionId}`);
-  lines.push(`**Task**: ${task}`);
-  lines.push(`**Result**: ${result}`);
-  lines.push(`**Iterations**: ${iterations}`);
-  lines.push(`**Duration**: ${Math.round((durationMs || 0) / 1000)}s`);
-
-  if (budget) {
-    lines.push(`**Budget**: ~$${budget.total_cost_usd?.toFixed(2) || "?"} / ~${budget.total_tokens?.toLocaleString() || "?"} tokens`);
-  }
-
-  if (stages && Object.keys(stages).length) {
-    lines.push("\n## Stages Executed\n");
-    for (const [name, stageResult] of Object.entries(stages)) {
-      const status = stageResult?.ok !== false ? "pass" : "fail";
-      const summary = stageResult?.summary || "";
-      lines.push(`- **${name}**: ${status}${summary ? ` -${summary}` : ""}`);
-    }
-  }
-
-  if (commits?.length) {
-    lines.push("\n## Commits\n");
-    for (const c of commits) lines.push(`- \`${(c.hash || "").slice(0, 7)}\` ${c.message || ""}`);
-  }
-
-  // List journal files
-  lines.push("\n## Journal Files\n");
-  for (const f of files) lines.push(`- [${f}](./${f})`);
-
-  return lines.join("\n");
-}
-
-// ── Pipeline plan display ────────────────────────────────────────────────────
-
-/**
- * Build a console-friendly pipeline plan summary.
- * Shown before the iteration loop starts.
- */
-export function buildPlanSummary({ pipelineFlags, config, stageResults, task }) {
-  const lines = [];
-  lines.push("┌─ Pipeline Plan ─────────────────────────────");
-
-  // Task (truncated)
-  const taskPreview = task.length > 80 ? task.slice(0, 77) + "..." : task;
-  lines.push(`│ Task: ${taskPreview}`);
-
-  // Triage result
-  const triage = stageResults?.triage;
-  if (triage) {
-    lines.push(`│ Triage: ${triage.level} (${triage.taskType || "sw"}) → roles: ${(triage.roles || []).join(", ")}`);
-  }
-
-  // Active stages
-  const activeStages = [];
-  if (pipelineFlags.researcherEnabled) activeStages.push("Researcher");
-  if (pipelineFlags.architectEnabled) activeStages.push("Architect");
-  if (pipelineFlags.plannerEnabled) activeStages.push("Planner");
-  activeStages.push("Coder");
-  if (pipelineFlags.refactorerEnabled) activeStages.push("Refactorer");
-  if (pipelineFlags.reviewerEnabled) activeStages.push("Reviewer");
-  if (pipelineFlags.testerEnabled) activeStages.push("Tester");
-  if (pipelineFlags.securityEnabled) activeStages.push("Security");
-  if (pipelineFlags.impeccableEnabled) activeStages.push("Impeccable");
-  if (pipelineFlags.perfEnabled) activeStages.push("Perf");
-  lines.push(`│ Stages: ${activeStages.join(" → ")}`);
-
-  // Config
-  const methodology = config.development?.methodology || "standard";
-  const maxIter = config.max_iterations || 5;
-  const solomonOn = config.pipeline?.solomon?.enabled !== false;
-  lines.push(`│ Method: ${methodology} | Max iterations: ${maxIter} | Solomon: ${solomonOn ? "on" : "off"}`);
-
-  // Plan summary (if planner ran)
-  const plan = stageResults?.planner;
-  if (plan?.plan) {
-    const planLines = plan.plan.split("\n").filter(l => l.trim());
-    const preview = planLines.slice(0, 5);
-    lines.push("│");
-    lines.push("│ Plan:");
-    for (const pl of preview) lines.push(`│   ${pl}`);
-    if (planLines.length > 5) lines.push(`│   ... (${planLines.length - 5} more steps)`);
-  }
-
-  lines.push("└──────────────────────────────────────────────");
-  return lines.join("\n");
-}
-
-// ── Main write functions ─────────────────────────────────────────────────────
-
-/**
- * Write all pre-loop stage outputs to the journal.
- */
-export async function writePreLoopJournal(journalDir, stageResults) {
-  const writes = [
-    { file: "triage.md", content: serializeTriage(stageResults.triage) },
-    { file: "discovery.md", content: serializeDiscovery(stageResults.discover) },
-    { file: "research.md", content: serializeResearch(stageResults.researcher) },
-    { file: "architecture.md", content: serializeArchitecture(stageResults.architect) },
-    { file: "plan.md", content: serializePlan(stageResults.planner) }
-  ];
-
-  await Promise.all(
-    writes.filter(w => w.content).map(w => writeJournalFile(journalDir, w.file, w.content))
-  );
-
-  return writes.filter(w => w.content).map(w => w.file);
-}
-
-/**
- * Write the iterations log.
- */
-export async function writeIterationsJournal(journalDir, iterationEntries) {
-  if (!iterationEntries?.length) return;
-  const content = "# Iterations\n\n" + iterationEntries.join("\n");
-  await writeJournalFile(journalDir, "iterations.md", content);
-}
-
-/**
- * Write the decisions log.
- */
-export async function writeDecisionsJournal(journalDir, decisionEntries) {
-  if (!decisionEntries?.length) return;
-  const content = "# Solomon Decisions\n\n" + decisionEntries.join("\n");
-  await writeJournalFile(journalDir, "decisions.md", content);
-}
-
-// writeTreeJournal / writeSummaryJournal / generateFileTree were
-// superseded in v2.7.x by src/session/journal/{tree-writer,summary-writer}.js
-// (the V2 split). post-loop.js dynamically imports the V2 versions; this
-// orchestrator-side copy is no longer wired anywhere. KJC-TSK-0354 PR-D.