@karajan-family/code 4.21.0

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

@@ -0,0 +1,142 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,189 @@
+// 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

@@ -0,0 +1,308 @@
+// 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.