karajan-code 1.59.0 → 2.0.0

package/src/orchestrator/preflight-checks.js

@@ -17,8 +17,10 @@ import { msg, getLang } from "../utils/messages.js";
 import {
   resolveSonarHost,
   resolveSonarToken,
+  resolveSonarTokenAsync,
   resolveSonarCredentials,
 } from "../sonar/config-resolver.js";
+import { saveSonarToken } from "../sonar/credentials.js";
 import { withDocLink } from "../utils/doc-links.js";
 
 function parseJsonSafe(text) {
@@ -75,8 +77,8 @@ async function checkSonarReachable(host) {
 async function checkSonarAuth(config) {
   const host = resolveSonarHost(config.sonarqube?.host);
 
-  // Check explicit token first
-  const explicitToken = resolveSonarToken(config);
+  // Check explicit token first (including persisted tokens from credentials file)
+  const explicitToken = await resolveSonarTokenAsync(config);
   if (explicitToken) {
     // Validate the token works
     const res = await runCommand("curl", [
@@ -117,7 +119,9 @@ async function checkSonarAuth(config) {
     if (tokenRes.exitCode !== 0) continue;
     const tokenParsed = parseJsonSafe(tokenRes.stdout);
     if (tokenParsed?.token) {
-      return { name: "sonar-auth", ok: true, detail: "Sonar token generated", token: tokenParsed.token };
+      // Persist the generated token for future sessions
+      try { await saveSonarToken(tokenParsed.token); } catch { /* non-blocking */ }
+      return { name: "sonar-auth", ok: true, detail: "Sonar token generated and saved", token: tokenParsed.token };
     }
   }
 

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

@@ -0,0 +1,190 @@
+// 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))
+  };
+}
+
+export { COMPRESSORS };

package/src/orchestrator/session-journal.js

@@ -0,0 +1,344 @@
+// 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";
+import { runCommand } from "../utils/process.js";
+
+/**
+ * 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");
+}
+
+// ── Tree of affected files ───────────────────────────────────────────────────
+
+export async function generateFileTree(baseRef) {
+  try {
+    const result = await runCommand("git", ["diff", "--name-status", `${baseRef}...HEAD`]);
+    if (result.exitCode !== 0 || !result.stdout?.trim()) return null;
+
+    const lines = ["# Affected Files\n"];
+    const statusMap = { M: "modified", A: "added", D: "deleted", R: "renamed" };
+
+    for (const line of result.stdout.trim().split("\n")) {
+      const [status, ...fileParts] = line.split("\t");
+      const file = fileParts.join("\t");
+      const label = statusMap[status?.[0]] || status;
+      lines.push(`- [${label}] ${file}`);
+    }
+
+    return lines.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+// ── 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");
+  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);
+}
+
+/**
+ * Write the file tree.
+ */
+export async function writeTreeJournal(journalDir, baseRef) {
+  const tree = await generateFileTree(baseRef);
+  if (tree) await writeJournalFile(journalDir, "tree.txt", tree);
+  return Boolean(tree);
+}
+
+/**
+ * Write the session summary.
+ */
+export async function writeSummaryJournal(journalDir, summaryData) {
+  const files = summaryData.files || [];
+  const content = generateSummary({ ...summaryData, files: [...files, "summary.md"] });
+  await writeJournalFile(journalDir, "summary.md", content);
+}

package/src/orchestrator/solomon-escalation.js

@@ -63,6 +63,24 @@ export function formatEscalationMessage(solomonResult, session) {
   return lines.join("\n");
 }
 
+/**
+ * Extract Solomon's previous rulings from session checkpoints.
+ * Gives Solomon memory of its own decisions to avoid repeating failed strategies.
+ */
+function extractSolomonHistory(session) {
+  const checkpoints = session?.checkpoints || [];
+  return checkpoints
+    .filter(cp => cp.stage === "solomon")
+    .map(cp => ({
+      conflictStage: cp.conflictStage,
+      ruling: cp.ruling,
+      alternativeAgent: cp.alternativeAgent,
+      waitUntil: cp.waitUntil,
+      conditions: cp.conditions,
+      error: cp.error || null
+    }));
+}
+
 export async function invokeSolomon({ config, logger, emitter, eventBase, stage, conflict, askQuestion, session, iteration }) {
   const solomonEnabled = Boolean(config.pipeline?.solomon?.enabled);
 
@@ -88,10 +106,14 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
   await solomon.init({ task: conflict.task || session.task, iteration });
   let ruling;
   try {
-    const conflictWithSuggestions = pendingSuggestions
-      ? { ...conflict, hostSuggestions: pendingSuggestions }
-      : conflict;
-    ruling = await solomon.run({ conflict: conflictWithSuggestions });
+    // Inject Solomon's own history so it doesn't repeat failed strategies
+    const solomonHistory = extractSolomonHistory(session);
+    const enrichedConflict = {
+      ...conflict,
+      ...(pendingSuggestions && { hostSuggestions: pendingSuggestions }),
+      ...(solomonHistory.length > 0 && { previousSolomonRulings: solomonHistory })
+    };
+    ruling = await solomon.run({ conflict: enrichedConflict });
   } catch (err) {
     logger.warn(`Solomon threw: ${err.message}`);
     return escalateToHuman({
@@ -124,7 +146,11 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
   await addCheckpoint(session, {
     stage: "solomon",
     iteration,
+    conflictStage: conflict?.stage || stage,
     ruling: ruling.result?.ruling,
+    alternativeAgent: ruling.result?.alternativeAgent || null,
+    waitUntil: ruling.result?.waitUntil || null,
+    conditions: ruling.result?.conditions || [],
     escalate: ruling.result?.escalate,
     error: solomonError ? solomonError.slice(0, 500) : undefined,
     subtask: ruling.result?.subtask?.title || null
@@ -143,7 +169,14 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
     return { action: "approve", conditions: [], ruling };
   }
   if (r === "approve_with_conditions") {
-    return { action: "continue", conditions: ruling.result?.conditions || [], ruling };
+    return {
+      action: "continue",
+      conditions: ruling.result?.conditions || [],
+      extraIterations: ruling.result?.extraIterations || null,
+      alternativeAgent: ruling.result?.alternativeAgent || null,
+      waitUntil: ruling.result?.waitUntil || null,
+      ruling
+    };
   }
 
   if (r === "escalate_human") {