@machinespirits/eval 0.2.0 → 0.3.0

package/services/evaluationRunner.js

@@ -21,10 +21,13 @@ import { generateLearnerResponse } from './learnerTutorInteractionEngine.js';
 import * as turnComparisonAnalyzer from './turnComparisonAnalyzer.js';
 import * as dialogueTraceAnalyzer from './dialogueTraceAnalyzer.js';
 import * as promptRewriter from './promptRewriter.js';
+import { mockGenerateResult, mockJudgeResult } from './mockProvider.js';
+import { formatEntry, formatTranscript, formatCompactLine } from './transcriptFormatter.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const EVAL_ROOT = path.resolve(__dirname, '..');
 const LOGS_DIR = path.join(EVAL_ROOT, 'logs', 'tutor-dialogues');
+const TRANSCRIPTS_DIR = path.join(EVAL_ROOT, 'logs', 'transcripts');
 
 // Redirect tutor-core logs to this repo's logs/ directory (if available)
 import('@machinespirits/tutor-core').then(mod => {
@@ -68,6 +71,33 @@ const EVAL_ONLY_PROFILES = [
   'cell_17_placebo_multi_unified', 'cell_18_placebo_multi_psycho',
   'cell_19_memory_single_unified', 'cell_20_recog_nomem_single_unified',
   'cell_21_recog_multi_unified_rewrite',
+  'cell_22_base_suspicious_unified', 'cell_23_recog_suspicious_unified',
+  'cell_24_base_adversary_unified', 'cell_25_recog_adversary_unified',
+  'cell_26_base_advocate_unified', 'cell_27_recog_advocate_unified',
+  'cell_28_base_dialectical_suspicious_unified', 'cell_29_recog_dialectical_suspicious_unified',
+  'cell_30_base_dialectical_adversary_unified', 'cell_31_recog_dialectical_adversary_unified',
+  'cell_32_base_dialectical_advocate_unified', 'cell_33_recog_dialectical_advocate_unified',
+  'cell_34_base_dialectical_suspicious_unified_full', 'cell_35_recog_dialectical_suspicious_unified_full',
+  'cell_36_base_dialectical_adversary_unified_full', 'cell_37_recog_dialectical_adversary_unified_full',
+  'cell_38_base_dialectical_advocate_unified_full', 'cell_39_recog_dialectical_advocate_unified_full',
+  'cell_40_base_dialectical_suspicious_unified_superego', 'cell_41_recog_dialectical_suspicious_unified_superego',
+  'cell_42_base_dialectical_adversary_unified_superego', 'cell_43_recog_dialectical_adversary_unified_superego',
+  'cell_44_base_dialectical_advocate_unified_superego', 'cell_45_recog_dialectical_advocate_unified_superego',
+  'cell_46_base_dialectical_suspicious_unified_quantitative', 'cell_47_recog_dialectical_suspicious_unified_quantitative',
+  'cell_48_base_dialectical_suspicious_unified_erosion', 'cell_49_recog_dialectical_suspicious_unified_erosion',
+  'cell_50_base_dialectical_suspicious_unified_intersubjective', 'cell_51_recog_dialectical_suspicious_unified_intersubjective',
+  'cell_52_base_dialectical_suspicious_unified_combined', 'cell_53_recog_dialectical_suspicious_unified_combined',
+  'cell_54_base_dialectical_profile_tutor', 'cell_55_recog_dialectical_profile_tutor',
+  'cell_56_base_dialectical_profile_bidirectional', 'cell_57_recog_dialectical_profile_bidirectional',
+  'cell_58_recog_dialectical_profile_bidirectional_full', 'cell_59_recog_dialectical_profile_bidirectional_strategy',
+  'cell_60_base_dialectical_selfreflect_psycho', 'cell_61_recog_dialectical_selfreflect_psycho',
+  'cell_62_base_dialectical_profile_bidirectional_psycho', 'cell_63_recog_dialectical_profile_bidirectional_psycho',
+  'cell_64_recog_dialectical_intersubjective_psycho', 'cell_65_recog_dialectical_combined_psycho',
+  'cell_66_recog_dialectical_profile_prosthesis_descriptive',
+  'cell_67_recog_dialectical_profile_prosthesis_prescriptive',
+  'cell_68_recog_dialectical_profile_prosthesis_adversary',
+  'cell_69_base_dialectical_intersubjective_psycho', 'cell_70_base_dialectical_combined_psycho',
+  'cell_71_naive_single_unified',
 ];
 
 /**
@@ -95,10 +125,24 @@ export function resolveEvalProfile(profileName) {
       resolvedProfileName = 'placebo';
     } else if (promptType === 'hardwired') {
       resolvedProfileName = 'hardwired';
+    } else if (promptType === 'naive') {
+      resolvedProfileName = 'naive';
     } else if (promptType === 'memory') {
       resolvedProfileName = 'memory';
     } else if (promptType === 'recognition_nomem') {
       resolvedProfileName = 'recognition_nomem';
+    } else if (promptType === 'divergent_suspicious') {
+      resolvedProfileName = recognitionMode ? 'suspicious_recognition' : 'suspicious';
+    } else if (promptType === 'divergent_adversary') {
+      resolvedProfileName = recognitionMode ? 'adversary_recognition' : 'adversary';
+    } else if (promptType === 'divergent_advocate') {
+      resolvedProfileName = recognitionMode ? 'advocate_recognition' : 'advocate';
+    } else if (promptType === 'dialectical_suspicious') {
+      resolvedProfileName = recognitionMode ? 'dialectical_suspicious_recognition' : 'dialectical_suspicious';
+    } else if (promptType === 'dialectical_adversary') {
+      resolvedProfileName = recognitionMode ? 'dialectical_adversary_recognition' : 'dialectical_adversary';
+    } else if (promptType === 'dialectical_advocate') {
+      resolvedProfileName = recognitionMode ? 'dialectical_advocate_recognition' : 'dialectical_advocate';
     } else if (recognitionMode) {
       resolvedProfileName = 'recognition';
     } else {
@@ -158,13 +202,23 @@ function resolveConfigModels(config) {
     // Extract factorial factor tags and learner architecture from profile
     const rawProfile = evalConfigLoader.loadTutorAgents()?.profiles?.[resolved.profileName];
     if (rawProfile?.factors) {
-      resolved.factors = rawProfile.factors;
+      resolved.factors = { ...rawProfile.factors };
+      // Normalize prompt_type → recognition boolean for DB storage
+      if (resolved.factors.prompt_type && resolved.factors.recognition == null) {
+        resolved.factors.recognition = resolved.factors.prompt_type === 'recognition';
+      }
     }
     if (rawProfile?.learner_architecture) {
       resolved.learnerArchitecture = rawProfile.learner_architecture;
     }
   }
 
+  // Apply CLI --max-tokens override (overrides ego max_tokens hyperparameter)
+  if (config.maxTokensOverride) {
+    if (!resolved.hyperparameters) resolved.hyperparameters = {};
+    resolved.hyperparameters = { ...resolved.hyperparameters, max_tokens: config.maxTokensOverride };
+  }
+
   // Apply CLI --model override (replaces ego and superego models, preserves factorial metadata)
   if (config.modelOverride) {
     try {
@@ -433,6 +487,8 @@ function buildMultiTurnContext(options) {
     conversationHistory = [],
     currentTurn,
     previousSuggestion,
+    priorSuperegoAssessments = [],
+    learnerTrajectory = null,
   } = options;
 
   const contextParts = [];
@@ -449,6 +505,26 @@ function buildMultiTurnContext(options) {
     }
   }
 
+  // Cross-turn superego memory: accumulated feedback from prior turns' internal
+  // deliberation. Visible to both ego (full context) and superego (via
+  // extractStructuredSummary fallback). Enables the superego to detect whether
+  // its prior feedback was incorporated and escalate if needed.
+  if (priorSuperegoAssessments.length > 0) {
+    contextParts.push('\n### Prior Superego Assessment');
+    for (const assessment of priorSuperegoAssessments) {
+      contextParts.push(formatSuperegoAssessment(assessment));
+    }
+  }
+
+  // Structured learner trajectory: pre-processed resistance/engagement signals
+  // derived from conversation history and score trajectory. Enables the superego
+  // to distinguish "learner asked a new question" from "learner is repeating the
+  // same confusion because our approach isn't working."
+  if (learnerTrajectory) {
+    contextParts.push('\n### Learner Trajectory Assessment');
+    contextParts.push(formatLearnerTrajectory(learnerTrajectory));
+  }
+
   // Note: "Previous Tutor Suggestion" block removed — it duplicated the last
   // entry already present in conversation history above.
 
@@ -464,6 +540,210 @@ function buildMultiTurnContext(options) {
   return contextParts.join('\n');
 }
 
+/**
+ * Extract superego feedback from a single turn's dialogue trace entries.
+ * Returns a structured assessment object for cross-turn memory.
+ */
+function extractTurnSuperegoAssessment(turnIndex, traceEntries) {
+  const superegoEntries = traceEntries.filter(e => e.agent === 'superego');
+  if (superegoEntries.length === 0) return null;
+
+  const lastEntry = superegoEntries[superegoEntries.length - 1];
+  const totalRejections = superegoEntries.filter(e => e.approved === false).length;
+  const totalApprovals = superegoEntries.filter(e => e.approved === true).length;
+  const interventionTypes = superegoEntries
+    .map(e => e.interventionType)
+    .filter(Boolean);
+
+  // Extract feedback text from last entry
+  let feedbackText = lastEntry.feedback || '';
+  if (!feedbackText && lastEntry.detail) {
+    const match = lastEntry.detail.match(/"feedback"\s*:\s*"([^"]+)"/);
+    if (match) feedbackText = match[1];
+  }
+
+  return {
+    turnIndex,
+    rejections: totalRejections,
+    approvals: totalApprovals,
+    interventionTypes,
+    finalApproved: lastEntry.approved,
+    confidence: lastEntry.confidence,
+    feedback: feedbackText.substring(0, 300),
+  };
+}
+
+/**
+ * Format a superego assessment for context injection.
+ */
+function formatSuperegoAssessment(assessment) {
+  const lines = [];
+  lines.push(`\n**Turn ${assessment.turnIndex + 1} internal critique:**`);
+  lines.push(`- Outcome: ${assessment.finalApproved ? 'approved' : 'rejected'} after ${assessment.rejections} rejection(s)`);
+  if (assessment.interventionTypes.length > 0) {
+    lines.push(`- Interventions: ${[...new Set(assessment.interventionTypes)].join(', ')}`);
+  }
+  if (assessment.feedback) {
+    lines.push(`- Key concern: "${assessment.feedback}"`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Analyze learner trajectory across turns to produce structured resistance signals.
+ * Returns null if insufficient data.
+ */
+function analyzeLearnerTrajectory(turnResults, conversationHistory) {
+  if (turnResults.length < 2) return null;
+
+  const trajectory = {
+    turnCount: turnResults.length,
+    engagementDirection: 'stable',
+    resistanceType: null,
+    resistanceStrength: 0,    // 0-3 scale
+    priorApproachEffective: null,
+    scoreTrajectory: [],
+    messageLengthTrajectory: [],
+    repeatedConfusion: false,
+    questionDiversity: 0,
+  };
+
+  // Score trajectory
+  trajectory.scoreTrajectory = turnResults
+    .filter(t => t.turnScore != null)
+    .map(t => t.turnScore);
+
+  // Message length trajectory (proxy for engagement)
+  const messageLengths = conversationHistory
+    .filter(h => h.learnerMessage)
+    .map(h => h.learnerMessage.length);
+  trajectory.messageLengthTrajectory = messageLengths;
+
+  // Engagement direction: declining if last 2 messages shorter than first 2
+  if (messageLengths.length >= 3) {
+    const earlyAvg = messageLengths.slice(0, 2).reduce((a, b) => a + b, 0) / 2;
+    const lateAvg = messageLengths.slice(-2).reduce((a, b) => a + b, 0) / 2;
+    if (lateAvg < earlyAvg * 0.6) trajectory.engagementDirection = 'declining';
+    else if (lateAvg > earlyAvg * 1.4) trajectory.engagementDirection = 'increasing';
+  }
+
+  // Score direction
+  if (trajectory.scoreTrajectory.length >= 2) {
+    const last = trajectory.scoreTrajectory[trajectory.scoreTrajectory.length - 1];
+    const prev = trajectory.scoreTrajectory[trajectory.scoreTrajectory.length - 2];
+    trajectory.priorApproachEffective = last >= prev;
+  }
+
+  // Repeated confusion detection: learner uses similar phrasing across turns
+  const learnerMessages = conversationHistory
+    .filter(h => h.learnerMessage)
+    .map(h => h.learnerMessage.toLowerCase());
+
+  if (learnerMessages.length >= 2) {
+    // Check for confusion markers repeating
+    const confusionPatterns = [
+      /i('m| am) (still )?(confused|lost|not sure|unsure)/i,
+      /i don'?t (understand|get|see)/i,
+      /what do you mean/i,
+      /can you explain/i,
+      /i('m| am) not following/i,
+    ];
+
+    const confusionCounts = learnerMessages.map(msg =>
+      confusionPatterns.filter(p => p.test(msg)).length
+    );
+    const lastTwoConfusion = confusionCounts.slice(-2);
+    if (lastTwoConfusion.length >= 2 && lastTwoConfusion.every(c => c > 0)) {
+      trajectory.repeatedConfusion = true;
+      trajectory.resistanceType = 'repeated_confusion';
+      trajectory.resistanceStrength = 2;
+    }
+  }
+
+  // Pushback detection
+  const lastMessage = learnerMessages[learnerMessages.length - 1] || '';
+  const pushbackPatterns = [
+    /\bbut\s+(what about|doesn'?t|isn'?t|that doesn'?t)\b/i,
+    /\bi disagree\b/i,
+    /\bi don'?t think\b/i,
+    /\bthat'?s not (right|correct|what i)\b/i,
+    /\byou('re| are) (wrong|missing|not)\b/i,
+  ];
+  if (pushbackPatterns.some(p => p.test(lastMessage))) {
+    trajectory.resistanceType = trajectory.resistanceType || 'pushback';
+    trajectory.resistanceStrength = Math.max(trajectory.resistanceStrength, 2);
+  }
+
+  // Disengagement detection: very short messages, no questions
+  if (messageLengths.length >= 2) {
+    const lastLen = messageLengths[messageLengths.length - 1];
+    if (lastLen < 30 && !lastMessage.includes('?')) {
+      trajectory.resistanceType = trajectory.resistanceType || 'disengagement';
+      trajectory.resistanceStrength = Math.max(trajectory.resistanceStrength, 1);
+      trajectory.engagementDirection = 'declining';
+    }
+  }
+
+  // Question diversity: how varied are the learner's questions?
+  const questions = learnerMessages.filter(m => m.includes('?'));
+  if (questions.length >= 2) {
+    // Simple word overlap check between consecutive questions
+    const uniqueQuestionWords = questions.map(q => new Set(q.split(/\s+/).filter(w => w.length > 3)));
+    let totalOverlap = 0;
+    for (let i = 1; i < uniqueQuestionWords.length; i++) {
+      const prev = uniqueQuestionWords[i - 1];
+      const curr = uniqueQuestionWords[i];
+      const overlap = [...curr].filter(w => prev.has(w)).length / Math.max(curr.size, 1);
+      totalOverlap += overlap;
+    }
+    trajectory.questionDiversity = 1 - (totalOverlap / Math.max(uniqueQuestionWords.length - 1, 1));
+  }
+
+  // Cumulative resistance: if score declining AND engagement declining, high resistance
+  if (trajectory.engagementDirection === 'declining' && trajectory.priorApproachEffective === false) {
+    trajectory.resistanceStrength = 3;
+    trajectory.resistanceType = trajectory.resistanceType || 'cumulative_decline';
+  }
+
+  return trajectory;
+}
+
+/**
+ * Format learner trajectory assessment for context injection.
+ */
+function formatLearnerTrajectory(trajectory) {
+  const lines = [];
+
+  // Engagement direction
+  const engagementEmoji = trajectory.engagementDirection === 'declining' ? 'DECLINING' :
+    trajectory.engagementDirection === 'increasing' ? 'INCREASING' : 'STABLE';
+  lines.push(`- Engagement: ${engagementEmoji} (over ${trajectory.turnCount} turns)`);
+
+  // Score trajectory
+  if (trajectory.scoreTrajectory.length >= 2) {
+    const scores = trajectory.scoreTrajectory.map(s => s.toFixed(0)).join(' → ');
+    lines.push(`- Score trajectory: ${scores}`);
+    lines.push(`- Prior approach effective: ${trajectory.priorApproachEffective ? 'YES' : 'NO'}`);
+  }
+
+  // Resistance
+  if (trajectory.resistanceType) {
+    const strengthLabel = ['none', 'mild', 'moderate', 'strong'][trajectory.resistanceStrength] || 'unknown';
+    lines.push(`- Resistance detected: ${trajectory.resistanceType} (${strengthLabel})`);
+  }
+
+  // Specific signals
+  if (trajectory.repeatedConfusion) {
+    lines.push(`- WARNING: Learner expressed confusion in consecutive turns — prior explanation did not land`);
+  }
+
+  if (trajectory.questionDiversity < 0.3 && trajectory.turnCount >= 3) {
+    lines.push(`- WARNING: Learner questions show low diversity — they may be stuck on the same concept`);
+  }
+
+  return lines.join('\n');
+}
+
 /**
  * Format a previous turn for inclusion in context
  */
@@ -649,26 +929,69 @@ async function generateAndEvaluateTurn(context, resolvedConfig, turnMeta, option
     log = () => {},
     scenarioId = '',
     systemPromptExtension = null,
+    superegoPromptExtension = null, // Dynamic disposition adjustments for superego
     learnerId = null, // For Writing Pad memory persistence
+    dialecticalNegotiation = false, // Phase 2: AI-powered dialectical struggle
+    behavioralOverrides = null, // Quantitative params from superego self-reflection
+    dryRun = false,
   } = options;
 
+  // Dry-run mode: return canned results without any API calls
+  if (dryRun) {
+    log('[dry-run] Generating mock suggestions (no API call)', 'info');
+    const genResult = mockGenerateResult(resolvedConfig, turnMeta);
+    const suggestion = genResult.suggestions?.[0];
+    const validation = suggestion
+      ? rubricEvaluator.quickValidate(suggestion, {
+          requiredElements: turnMeta.requiredElements,
+          requiredElementsAny: turnMeta.requiredElementsAny,
+          forbiddenElements: turnMeta.forbiddenElements,
+        })
+      : { passesRequired: false, passesForbidden: true, requiredMissing: ['No suggestions generated'] };
+
+    let rubricResult = null;
+    let turnScore = null;
+    let scoringMethod = 'skipped';
+    if (!skipRubricEval && suggestion) {
+      log('[dry-run] Generating mock judge scores (no API call)', 'info');
+      rubricResult = mockJudgeResult(resolvedConfig, scenarioId + Date.now());
+      turnScore = rubricResult.overallScore;
+      scoringMethod = 'rubric';
+    }
+
+    return { genResult, suggestion, validation, rubricResult, turnScore, scoringMethod };
+  }
+
   // Generate suggestions via tutor API with retry logic
+  // Note: retryWithBackoff handles thrown errors, but tutorApi.generateSuggestions()
+  // catches its own errors and returns { success: false }. We need to also handle
+  // 429 rate limit errors returned in the result (not thrown).
   const genResult = await retryWithBackoff(
-    () => tutorApi.generateSuggestions(context, {
-      provider: resolvedConfig.provider,
-      model: resolvedConfig.model,
-      egoModel: resolvedConfig.egoModel,
-      superegoModel: resolvedConfig.superegoModel || null,
-      profileName: resolvedConfig.profileName,
-      hyperparameters: resolvedConfig.hyperparameters || {},
-      trace: true,
-      superegoStrategy,
-      outputSize,
-      useDialogue,
-      maxRounds,
-      systemPromptExtension,
-      learnerId, // Activates Writing Pad three-layer memory
-    }),
+    async () => {
+      const result = await tutorApi.generateSuggestions(context, {
+        provider: resolvedConfig.provider,
+        model: resolvedConfig.model,
+        egoModel: resolvedConfig.egoModel,
+        superegoModel: resolvedConfig.superegoModel || null,
+        profileName: resolvedConfig.profileName,
+        hyperparameters: resolvedConfig.hyperparameters || {},
+        trace: true,
+        superegoStrategy,
+        outputSize,
+        useDialogue,
+        maxRounds,
+        systemPromptExtension,
+        superegoPromptExtension, // Dynamic disposition adjustments for superego
+        learnerId, // Activates Writing Pad three-layer memory
+        dialecticalNegotiation, // Phase 2: AI-powered dialectical struggle
+        behavioralOverrides, // Quantitative params from superego self-reflection
+      });
+      // Re-throw 429 errors so retryWithBackoff can handle them
+      if (!result.success && result.error && (result.error.includes('429') || result.error.toLowerCase().includes('rate limit'))) {
+        throw new Error(result.error);
+      }
+      return result;
+    },
     { log }
   );
 
@@ -776,9 +1099,13 @@ export async function runEvaluation(options = {}) {
     description = null,
     verbose = false,
     scenarioFilter = null,      // Cluster filter: 'single-turn', 'multi-turn', or category names
-    modelOverride = null,       // CLI --model override (e.g. "openrouter.nemotron")
-    egoModelOverride = null,    // CLI --ego-model override (replaces only ego model)
-    superegoModelOverride = null, // CLI --superego-model override (replaces only superego model)
+    modelOverride = null,       // CLI --model override (e.g. "openrouter.nemotron") — ALL agents
+    egoModelOverride = null,    // CLI --ego-model override (replaces only tutor ego model)
+    superegoModelOverride = null, // CLI --superego-model override (replaces only tutor superego model)
+    learnerModelOverride = null, // CLI --learner-model override (replaces all learner agent models)
+    dryRun = false,             // Use mock data instead of API calls
+    transcriptMode = false,     // Write play-format transcript files during multi-turn runs
+    maxTokensOverride = null,   // CLI --max-tokens override (replaces ego max_tokens hyperparameter)
   } = options;
 
   const log = verbose ? console.log : () => {};
@@ -856,6 +1183,7 @@ export async function runEvaluation(options = {}) {
   const effectiveModelOverride = modelOverride || yamlOverrides.modelOverride;
   const effectiveEgoModelOverride = egoModelOverride || yamlOverrides.egoModelOverride;
   const effectiveSuperegoModelOverride = superegoModelOverride || yamlOverrides.superegoModelOverride;
+  const effectiveLearnerModelOverride = learnerModelOverride || null;
 
   if (effectiveModelOverride) {
     targetConfigs = targetConfigs.map(c => ({ ...c, modelOverride: effectiveModelOverride }));
@@ -866,6 +1194,12 @@ export async function runEvaluation(options = {}) {
   if (effectiveSuperegoModelOverride) {
     targetConfigs = targetConfigs.map(c => ({ ...c, superegoModelOverride: effectiveSuperegoModelOverride }));
   }
+  if (effectiveLearnerModelOverride) {
+    targetConfigs = targetConfigs.map(c => ({ ...c, learnerModelOverride: effectiveLearnerModelOverride }));
+  }
+  if (maxTokensOverride) {
+    targetConfigs = targetConfigs.map(c => ({ ...c, maxTokensOverride }));
+  }
 
   if (targetConfigs.length === 0) {
     throw new Error('No configurations to test');
@@ -888,6 +1222,8 @@ export async function runEvaluation(options = {}) {
       modelOverride: effectiveModelOverride || null,
       egoModelOverride: effectiveEgoModelOverride || null,
       superegoModelOverride: effectiveSuperegoModelOverride || null,
+      learnerModelOverride: effectiveLearnerModelOverride || null,
+      maxTokensOverride: maxTokensOverride || null,
       // Store scenario IDs and profile names for accurate resume
       scenarioIds: targetScenarios.map(s => s.id),
       profileNames: targetConfigs.map(c => c.profileName).filter(Boolean),
@@ -1002,6 +1338,9 @@ export async function runEvaluation(options = {}) {
       const result = await runSingleTest(scenario, config, {
         skipRubricEval,
         verbose,
+        dryRun,
+        transcriptMode,
+        runId: run.id,
       });
 
       // Store result (better-sqlite3 is synchronous, thread-safe for concurrent writes)
@@ -1071,30 +1410,38 @@ export async function runEvaluation(options = {}) {
       completedTests++;
       log(`  ${formatProgress(completedTests, totalTests, runStartTime)} ${profileLabel} / ${scenario.id}: ERROR - ${error.message}`);
 
-      // Store failed result so it shows up in the database instead of silently disappearing
-      // Extract provider/model from nested ego config if not at top level (profile-based configs)
-      const failedResult = {
-        scenarioId: scenario.id,
-        scenarioName: scenario.name || scenario.id,
-        profileName: config.profileName,
-        provider: config.provider || config.ego?.provider || 'unknown',
-        model: config.model || config.ego?.model || 'unknown',
-        egoModel: config.egoModel
-          ? `${config.egoModel.provider}.${config.egoModel.model}`
-          : config.ego ? `${config.ego.provider}.${config.ego.model}` : null,
-        superegoModel: config.superegoModel
-          ? `${config.superegoModel.provider}.${config.superegoModel.model}`
-          : config.superego ? `${config.superego.provider}.${config.superego.model}` : null,
-        factors: config.factors || null,
-        learnerArchitecture: config.learnerArchitecture || null,
-        success: false,
-        errorMessage: error.message,
-      };
-      try {
-        evaluationStore.storeResult(run.id, failedResult);
-        results.push(failedResult);
-      } catch (storeErr) {
-        log(`  [WARNING] Failed to store error result: ${storeErr.message}`);
+      // Only store failed results for permanent errors (bad config, invalid scenario).
+      // Skip storing for retriable/transient errors (rate limits, model unavailable, timeouts)
+      // so that `resume` can retry them without needing manual cleanup.
+      const errMsg = error.message || '';
+      const isTransient = /429|rate limit|too many requests|503|502|timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|terminated|unavailable|failed to generate suggestions/i.test(errMsg);
+
+      if (!isTransient) {
+        const failedResult = {
+          scenarioId: scenario.id,
+          scenarioName: scenario.name || scenario.id,
+          profileName: config.profileName,
+          provider: config.provider || config.ego?.provider || 'unknown',
+          model: config.model || config.ego?.model || 'unknown',
+          egoModel: config.egoModel
+            ? `${config.egoModel.provider}.${config.egoModel.model}`
+            : config.ego ? `${config.ego.provider}.${config.ego.model}` : null,
+          superegoModel: config.superegoModel
+            ? `${config.superegoModel.provider}.${config.superegoModel.model}`
+            : config.superego ? `${config.superego.provider}.${config.superego.model}` : null,
+          factors: config.factors || null,
+          learnerArchitecture: config.learnerArchitecture || null,
+          success: false,
+          errorMessage: error.message,
+        };
+        try {
+          evaluationStore.storeResult(run.id, failedResult);
+          results.push(failedResult);
+        } catch (storeErr) {
+          log(`  [WARNING] Failed to store error result: ${storeErr.message}`);
+        }
+      } else {
+        log(`  [SKIPPED] Transient error, not storing empty row (resumable): ${errMsg.substring(0, 100)}`);
       }
 
       // Emit test_error event
@@ -1183,7 +1530,7 @@ export async function runEvaluation(options = {}) {
  * Handles both single-turn and multi-turn scenarios
  */
 async function runSingleTest(scenario, config, options = {}) {
-  const { skipRubricEval = false, outputSize = 'normal', verbose = false, onLog, superegoStrategy = null, judgeOverride = null } = options;
+  const { skipRubricEval = false, outputSize = 'normal', verbose = false, onLog, superegoStrategy = null, judgeOverride = null, dryRun = false } = options;
 
   // Create a log function that calls both console and onLog callback
   const log = (message, level = 'info') => {
@@ -1214,7 +1561,7 @@ async function runSingleTest(scenario, config, options = {}) {
  * Run a single-turn test
  */
 async function runSingleTurnTest(scenario, config, fullScenario, options = {}) {
-  const { skipRubricEval = false, outputSize = 'normal', verbose = false, log = () => {}, superegoStrategy = null, judgeOverride = null } = options;
+  const { skipRubricEval = false, outputSize = 'normal', verbose = false, log = () => {}, superegoStrategy = null, judgeOverride = null, dryRun = false } = options;
 
   // Resolve model aliases through eval's providers.yaml
   const resolvedConfig = resolveConfigModels(config);
@@ -1260,7 +1607,7 @@ async function runSingleTurnTest(scenario, config, fullScenario, options = {}) {
       requiredElementsAny: fullScenario.required_elements_any,
       forbiddenElements: fullScenario.forbidden_elements,
     },
-    { skipRubricEval, outputSize, superegoStrategy, judgeOverride, useDialogue, maxRounds, log, scenarioId: scenario.id }
+    { skipRubricEval, outputSize, superegoStrategy, judgeOverride, useDialogue, maxRounds, log, scenarioId: scenario.id, dryRun }
   );
 
   if (!genResult.success) {
@@ -1296,7 +1643,7 @@ async function runSingleTurnTest(scenario, config, fullScenario, options = {}) {
     superegoModel: resolvedConfig.superegoModel
       ? `${resolvedConfig.superegoModel.provider}.${resolvedConfig.superegoModel.model}`
       : null,
-    hyperparameters: config.hyperparameters,
+    hyperparameters: resolvedConfig.hyperparameters || config.hyperparameters,
     suggestions: genResult.suggestions,
     success: true,
     latencyMs: genResult.metadata?.latencyMs,
@@ -1346,7 +1693,7 @@ async function runSingleTurnTest(scenario, config, fullScenario, options = {}) {
  * This eliminates the separate multiTurnRunner orchestration.
  */
 async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
-  const { skipRubricEval = false, outputSize = 'normal', verbose = false, log = () => {}, superegoStrategy = null, judgeOverride = null } = options;
+  const { skipRubricEval = false, outputSize = 'normal', verbose = false, log = () => {}, superegoStrategy = null, judgeOverride = null, dryRun = false, transcriptMode = false, runId = null } = options;
 
   log(`[evaluationRunner] Running multi-turn scenario: ${scenario.id}`);
 
@@ -1371,6 +1718,41 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
   const learnerId = `eval-learner-${dialogueId}-${scenario.id.replace(/[^a-zA-Z0-9]/g, '')}`;
   log(`[evaluationRunner] Generated learnerId for Writing Pad: ${learnerId}`, 'info');
 
+  // Set up transcript file for incremental writing (tail -f friendly)
+  let transcriptPath = null;
+  if (transcriptMode) {
+    const effectiveRunId = runId || 'live';
+    const transcriptDir = path.join(TRANSCRIPTS_DIR, effectiveRunId);
+    if (!fs.existsSync(transcriptDir)) fs.mkdirSync(transcriptDir, { recursive: true });
+    const safeName = `${config.profileName}--${scenario.id}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    transcriptPath = path.join(transcriptDir, `${safeName}.txt`);
+    // Write header
+    const totalTurnCount = 1 + (fullScenario.turns || []).length;
+    const header = `\n${(fullScenario.name || scenario.id).toUpperCase()} (${totalTurnCount}-turn)\n${config.profileName}\n${'─'.repeat(40)}\n\n`;
+    fs.writeFileSync(transcriptPath, header);
+    log(`[evaluationRunner] Transcript: ${transcriptPath}`, 'info');
+  }
+
+  // Helper: append new trace entries to transcript file and optionally console
+  let lastTranscriptIdx = 0;
+  function flushTranscript() {
+    if (!transcriptMode || !transcriptPath) return;
+    const newEntries = consolidatedTrace.slice(lastTranscriptIdx);
+    if (newEntries.length === 0) return;
+    lastTranscriptIdx = consolidatedTrace.length;
+    const lines = [];
+    for (const entry of newEntries) {
+      const formatted = formatEntry(entry, { detail: 'play' });
+      if (formatted) lines.push(formatted + '\n');
+      // Also print compact line to console in transcript mode
+      const compactLine = formatCompactLine(entry);
+      if (compactLine) console.log(compactLine);
+    }
+    if (lines.length > 0) {
+      fs.appendFileSync(transcriptPath, lines.join('\n'));
+    }
+  }
+
   // Deep-clone turns to prevent mutation of shared scenario objects across profiles
   const turns = JSON.parse(JSON.stringify(fullScenario.turns || []));
   const turnResults = [];
@@ -1384,14 +1766,58 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
   let conversationHistory = [];
   let previousSuggestion = null;
   const consolidatedTrace = [];
+  const priorSuperegoAssessments = [];  // Cross-turn superego memory
 
-  const sharedTurnOptions = { skipRubricEval, outputSize, superegoStrategy, judgeOverride, useDialogue, maxRounds, log, scenarioId: scenario.id, learnerId };
-
-  // Check if prompt rewriting is enabled for this profile
+  // Check profile-level feature flags
   const rawProfile = evalConfigLoader.loadTutorAgents()?.profiles?.[config.profileName];
+
+  // Apply CLI model override to rawProfile so prompt rewriter calls use the correct model.
+  // Without this, --model/--ego-model only affects tutor-core's generateSuggestions,
+  // while promptRewriter functions (self-reflection, profiling, etc.) still use the YAML model.
+  if (config.modelOverride || config.egoModelOverride) {
+    const overrideModel = config.egoModelOverride || config.modelOverride;
+    try {
+      const r = evalConfigLoader.resolveModel(overrideModel);
+      if (rawProfile?.ego) {
+        rawProfile.ego = { ...rawProfile.ego, provider: r.provider, model: r.model };
+      }
+      // Also update top-level model for functions that read config.model
+      if (rawProfile) rawProfile.model = r.model;
+    } catch { /* leave rawProfile as-is if resolution fails */ }
+  }
+  if (config.modelOverride || config.superegoModelOverride) {
+    const overrideModel = config.superegoModelOverride || config.modelOverride;
+    try {
+      const r = evalConfigLoader.resolveModel(overrideModel);
+      if (rawProfile?.superego) {
+        rawProfile.superego = { ...rawProfile.superego, provider: r.provider, model: r.model };
+      }
+    } catch { /* leave rawProfile as-is if resolution fails */ }
+  }
+
+  const dialecticalNegotiation = rawProfile?.dialectical_negotiation ?? false;
   const promptRewritingEnabled = rawProfile?.prompt_rewriting?.enabled ?? false;
   const promptRewritingStrategy = rawProfile?.prompt_rewriting?.strategy ?? 'template';
+  const superegoDispositionRewriting = rawProfile?.superego_disposition_rewriting ?? false;
+  const quantitativeDispositionEnabled = rawProfile?.prompt_rewriting?.quantitative_disposition ?? false;
+  const promptErosionEnabled = rawProfile?.prompt_rewriting?.prompt_erosion?.enabled ?? false;
+  const intersubjectiveEnabled = rawProfile?.prompt_rewriting?.intersubjective ?? false;
+  const otherEgoProfilingEnabled = rawProfile?.other_ego_profiling?.enabled ?? false;
+  const otherEgoBidirectional = rawProfile?.other_ego_profiling?.bidirectional ?? false;
+  const strategyPlanningEnabled = rawProfile?.other_ego_profiling?.strategy_planning ?? false;
+
+  const sharedTurnOptions = { skipRubricEval, outputSize, superegoStrategy, judgeOverride, useDialogue, maxRounds, log, scenarioId: scenario.id, learnerId, dialecticalNegotiation, dryRun };
   let sessionEvolution = null;
+  let superegoEvolution = null;
+  let behavioralOverrides = null; // Parsed quantitative params from superego self-reflection
+  let tutorProfileOfLearner = null;  // Other-ego: tutor's mental model of learner
+  let learnerProfileOfTutor = null;  // Other-ego: learner's mental model of tutor
+  let strategyPlan = null;           // Other-ego: ego's explicit strategy plan
+
+  // Per-dialogue rejection budget: limits total superego rejections across all turns
+  // to prevent worst-case cascade (e.g., 3 rejections × 5 turns = 15 total)
+  let rejectionBudget = rawProfile?.dialogue?.rejection_budget ?? null;  // null = unlimited (backwards-compatible)
+  let totalRejections = 0;
 
   // 4. Loop through turns (initial turn 0 + follow-up turns)
   const totalTurnCount = 1 + turns.length;
@@ -1401,6 +1827,19 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
 
     log(`[evaluationRunner] Turn ${turnIdx}/${totalTurnCount - 1}${isInitialTurn ? ' (initial)' : ` (${turnDef.id})`}`, 'info');
 
+    // Update run metadata with current turn progress for `runs` command
+    if (runId) {
+      evaluationStore.updateRun(runId, {
+        metadata: {
+          turnProgress: {
+            current: turnIdx + 1,
+            total: totalTurnCount,
+            scenarioId: scenario.id,
+          }
+        }
+      });
+    }
+
     // Show learner action in transcript mode (for follow-up turns)
     if (!isInitialTurn && dialogueEngine.isTranscriptMode()) {
       dialogueEngine.transcript('LEARNER ACTION', formatLearnerActionForTranscript(turnDef));
@@ -1420,11 +1859,16 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
         learnerMessage: turnDef.action_details?.message,
       });
 
+      // Build learner trajectory assessment from accumulated turn data
+      const learnerTrajectory = analyzeLearnerTrajectory(turnResults, conversationHistory);
+
       contextStr = buildMultiTurnContext({
         originalContext: fullScenario.learner_context,
         conversationHistory,
         currentTurn: turnDef,
         previousSuggestion,
+        priorSuperegoAssessments,
+        learnerTrajectory,
       });
     }
 
@@ -1455,11 +1899,46 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
         : (turnDef.forbidden_elements || []),
     };
 
+    // Build the ego prompt extension: erosion frame + session evolution (reflections)
+    let fullEgoExtension = sessionEvolution;
+    if (promptErosionEnabled && turnIdx > 0) {
+      const erosionFrame = promptRewriter.buildPromptErosionFrame(turnIdx, rawProfile);
+      if (erosionFrame) {
+        // Erosion frame goes BEFORE reflections, so the model sees authority calibration first
+        fullEgoExtension = erosionFrame + (sessionEvolution ? '\n\n' + sessionEvolution : '');
+        log(`[evaluationRunner] Prompt erosion frame applied for turn ${turnIdx} (rate=${rawProfile.prompt_rewriting?.prompt_erosion?.rate ?? 0.2})`, 'info');
+      }
+    }
+
+    // Append other-ego profile and strategy plan to ego extension
+    // Injection order: erosion frame → self-reflection → other-ego profile → strategy plan
+    if (otherEgoProfilingEnabled && tutorProfileOfLearner) {
+      const profileBlock = promptRewriter.formatProfileForInjection(tutorProfileOfLearner, 'learner');
+      fullEgoExtension = (fullEgoExtension ? fullEgoExtension + '\n\n' : '') + profileBlock;
+    }
+    if (strategyPlanningEnabled && strategyPlan) {
+      fullEgoExtension = (fullEgoExtension ? fullEgoExtension + '\n\n' : '') + strategyPlan;
+    }
+
+    // Build the superego prompt extension: erosion frame + superego evolution (reflections)
+    let fullSuperegoExtension = superegoEvolution;
+    if (promptErosionEnabled && turnIdx > 0 && superegoEvolution) {
+      const erosionFrame = promptRewriter.buildPromptErosionFrame(turnIdx, rawProfile);
+      if (erosionFrame) {
+        fullSuperegoExtension = erosionFrame + '\n\n' + superegoEvolution;
+      }
+    }
+
     // Call the SAME generation+evaluation code path as single-turn
     // Pass dialogue context so the judge can see the full exchange
+    // When rejection budget is exhausted, also skip outer superego review loop (maxRounds: 0)
+    const budgetExhausted = rejectionBudget !== null && totalRejections >= rejectionBudget;
     const turnOptions = {
       ...sharedTurnOptions,
-      ...(sessionEvolution ? { systemPromptExtension: sessionEvolution } : {}),
+      ...(fullEgoExtension ? { systemPromptExtension: fullEgoExtension } : {}),
+      ...(fullSuperegoExtension ? { superegoPromptExtension: fullSuperegoExtension } : {}),
+      ...(behavioralOverrides ? { behavioralOverrides } : {}),
+      ...(budgetExhausted ? { maxRounds: 0 } : {}),
       conversationHistory: conversationHistory.length > 0 ? conversationHistory : null,
       consolidatedTrace: consolidatedTrace.length > 0 ? consolidatedTrace : null,
     };
@@ -1468,7 +1947,7 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
 
     if (!genResult.success) {
       const turnId = isInitialTurn ? 'initial' : turnDef.id;
-      throw new Error(`Multi-turn scenario ${scenario.id}: Turn ${turnIdx} (${turnId}) failed to generate suggestions`);
+      throw new Error(`Multi-turn scenario ${scenario.id}: Turn ${turnIdx} (${turnId}) failed to generate suggestions: ${genResult.error || 'unknown error'}`);
     }
 
     // Accumulate dialogue traces
@@ -1506,6 +1985,39 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
       }
     }
 
+    // Flush transcript: ego/superego exchange for this turn
+    flushTranscript();
+
+    // Accumulate cross-turn superego memory from this turn's trace
+    if (genResult.dialogueTrace && genResult.dialogueTrace.length > 0) {
+      const assessment = extractTurnSuperegoAssessment(turnIdx, genResult.dialogueTrace);
+      if (assessment) {
+        priorSuperegoAssessments.push(assessment);
+      }
+    }
+
+    // Track rejection budget across turns: count superego rejections in this turn's trace
+    if (rejectionBudget !== null && genResult.dialogueTrace) {
+      const turnRejections = genResult.dialogueTrace.filter(
+        entry => entry.agent === 'superego' && entry.action === 'review' && entry.approved === false
+      ).length;
+      totalRejections += turnRejections;
+
+      if (totalRejections >= rejectionBudget) {
+        // Budget exhausted: force approve-only mode for remaining turns
+        behavioralOverrides = { ...(behavioralOverrides || {}), max_rejections: 0 };
+        log(`[evaluationRunner] Rejection budget exhausted (${totalRejections}/${rejectionBudget}): forcing approve-only for remaining turns`, 'info');
+        consolidatedTrace.push({
+          agent: 'rejection_budget',
+          action: 'exhausted',
+          turnIndex: turnIdx,
+          contextSummary: `Budget exhausted: ${totalRejections}/${rejectionBudget} rejections used`,
+          detail: `Total rejections across ${turnIdx + 1} turns: ${totalRejections}. Remaining turns will auto-approve.`,
+          timestamp: new Date().toISOString(),
+        });
+      }
+    }
+
     // Collect per-turn result
     turnResults.push({
       turnIndex: turnIdx,
@@ -1546,41 +2058,368 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
     // Update for next iteration
     previousSuggestion = suggestion;
 
-    // Synthesize prompt rewriting directives for next turn (if enabled)
-    if (promptRewritingEnabled && turnIdx < totalTurnCount - 1) {
-      if (promptRewritingStrategy === 'llm') {
-        // LLM-based directive synthesis using superego model
-        try {
-          sessionEvolution = await promptRewriter.synthesizeDirectivesLLM({
+    // ── Between-turn processing ──────────────────────────────────────────
+    // Parallelized into groups by dependency:
+    //   Group 1 (independent): ego self-refl, superego self-refl, tutor profile, learner profile
+    //   Group 2 (depends on group 1): intersubjective, quantitative parse, strategy plan
+    //   Group 3 (depends on group 2): learner generation
+    // This collapses ~6-8 sequential LLM calls into ~3 parallel rounds.
+
+    if (turnIdx < totalTurnCount - 1) {
+      const betweenTurnStart = Date.now();
+
+      // ── Group 1: Independent LLM calls in parallel ──────────────────
+      const group1Promises = [];
+      const group1Labels = [];
+
+      // Ego self-reflection / prompt rewriting
+      if (promptRewritingEnabled) {
+        if (promptRewritingStrategy === 'self_reflection') {
+          group1Promises.push(
+            promptRewriter.synthesizeEgoSelfReflection({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+              config: rawProfile,
+            }).catch(error => {
+              log(`[evaluationRunner] Ego self-reflection failed, will fall back to template: ${error.message}`, 'warn');
+              return null;
+            })
+          );
+          group1Labels.push('ego_self_reflection');
+        } else if (promptRewritingStrategy === 'llm') {
+          group1Promises.push(
+            promptRewriter.synthesizeDirectivesLLM({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+              config: rawProfile,
+            }).catch(error => {
+              log(`[evaluationRunner] LLM rewriter failed, will fall back to template: ${error.message}`, 'warn');
+              return null;
+            })
+          );
+          group1Labels.push('llm_rewrite');
+        }
+      }
+
+      // Superego self-reflection / disposition rewriting
+      if (superegoDispositionRewriting) {
+        if (promptRewritingStrategy === 'self_reflection') {
+          group1Promises.push(
+            promptRewriter.synthesizeSupergoSelfReflection({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+              priorSuperegoAssessments,
+              config: rawProfile,
+            }).catch(error => {
+              log(`[evaluationRunner] Superego self-reflection failed: ${error.message}`, 'warn');
+              return null;
+            })
+          );
+          group1Labels.push('superego_self_reflection');
+        } else {
+          group1Promises.push(
+            promptRewriter.synthesizeSuperegoDisposition({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+              priorSuperegoAssessments,
+              config: rawProfile,
+            }).catch(error => {
+              log(`[evaluationRunner] Superego disposition rewriting failed: ${error.message}`, 'warn');
+              return null;
+            })
+          );
+          group1Labels.push('superego_disposition');
+        }
+      }
+
+      // Tutor profiles learner (Theory of Mind)
+      if (otherEgoProfilingEnabled) {
+        group1Promises.push(
+          promptRewriter.synthesizeTutorProfileOfLearner({
             turnResults,
             consolidatedTrace,
             conversationHistory,
+            priorProfile: tutorProfileOfLearner,
             config: rawProfile,
-          });
+          }).catch(error => {
+            log(`[evaluationRunner] Tutor profile of learner failed: ${error.message}`, 'warn');
+            return null;
+          })
+        );
+        group1Labels.push('tutor_profile');
+      }
+
+      // Learner profiles tutor (bidirectional Theory of Mind)
+      if (otherEgoProfilingEnabled && otherEgoBidirectional) {
+        group1Promises.push(
+          promptRewriter.synthesizeLearnerProfileOfTutor({
+            turnResults,
+            consolidatedTrace,
+            conversationHistory,
+            priorProfile: learnerProfileOfTutor,
+            config: rawProfile,
+          }).catch(error => {
+            log(`[evaluationRunner] Learner profile of tutor failed: ${error.message}`, 'warn');
+            return null;
+          })
+        );
+        group1Labels.push('learner_profile');
+      }
+
+      // Fire all group 1 calls in parallel
+      const group1Results = await Promise.all(group1Promises);
+      const group1Map = {};
+      group1Labels.forEach((label, i) => { group1Map[label] = group1Results[i]; });
+
+      // ── Process group 1 results ─────────────────────────────────────
+
+      // Ego self-reflection / prompt rewriting result
+      if (promptRewritingEnabled) {
+        if (promptRewritingStrategy === 'self_reflection') {
+          const egoReflResult = group1Map['ego_self_reflection'];
+          sessionEvolution = egoReflResult?.text ?? null;
+          if (sessionEvolution) {
+            log(`[evaluationRunner] Ego self-reflection generated for turn ${turnIdx + 1}`, 'info');
+            consolidatedTrace.push({
+              agent: 'ego_self_reflection',
+              action: 'rewrite',
+              turnIndex: turnIdx,
+              contextSummary: `Ego self-reflection generated for turn ${turnIdx + 1}`,
+              detail: sessionEvolution,
+              metrics: egoReflResult?.metrics ?? null,
+              timestamp: new Date().toISOString(),
+            });
+          } else {
+            log(`[evaluationRunner] Ego self-reflection returned empty, falling back to template for turn ${turnIdx + 1}`, 'warn');
+            sessionEvolution = promptRewriter.synthesizeDirectives({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+            });
+          }
+        } else if (promptRewritingStrategy === 'llm') {
+          const llmResult = group1Map['llm_rewrite'];
+          sessionEvolution = llmResult?.text ?? null;
           if (sessionEvolution) {
             log(`[evaluationRunner] LLM rewriter generated directives for turn ${turnIdx + 1}`, 'info');
+          } else {
+            log(`[evaluationRunner] LLM rewriter returned empty, falling back to template for turn ${turnIdx + 1}`, 'warn');
+            sessionEvolution = promptRewriter.synthesizeDirectives({
+              turnResults,
+              consolidatedTrace,
+              conversationHistory,
+            });
           }
-        } catch (error) {
-          log(`[evaluationRunner] LLM rewriter failed, falling back to template: ${error.message}`, 'warn');
+        } else {
+          // Template-based directive synthesis (deterministic, no LLM call)
           sessionEvolution = promptRewriter.synthesizeDirectives({
             turnResults,
             consolidatedTrace,
             conversationHistory,
           });
         }
-      } else {
-        // Template-based directive synthesis (deterministic, no LLM call)
-        sessionEvolution = promptRewriter.synthesizeDirectives({
-          turnResults,
-          consolidatedTrace,
-          conversationHistory,
-        });
+        if (sessionEvolution) {
+          log(`[evaluationRunner] Prompt rewriter (${promptRewritingStrategy}) generated ${sessionEvolution.split('\n').length - 2} directives for turn ${turnIdx + 1}`, 'info');
+        }
       }
-      if (sessionEvolution) {
-        log(`[evaluationRunner] Prompt rewriter (${promptRewritingStrategy}) generated ${sessionEvolution.split('\n').length - 2} directives for turn ${turnIdx + 1}`, 'info');
+
+      // Superego self-reflection / disposition result
+      if (superegoDispositionRewriting) {
+        if (promptRewritingStrategy === 'self_reflection') {
+          const seReflResult = group1Map['superego_self_reflection'];
+          superegoEvolution = seReflResult?.text ?? null;
+          if (superegoEvolution) {
+            log(`[evaluationRunner] Superego self-reflection generated for turn ${turnIdx + 1}`, 'info');
+            consolidatedTrace.push({
+              agent: 'superego_self_reflection',
+              action: 'rewrite',
+              turnIndex: turnIdx,
+              contextSummary: `Superego self-reflection generated for turn ${turnIdx + 1}`,
+              detail: superegoEvolution,
+              metrics: seReflResult?.metrics ?? null,
+              timestamp: new Date().toISOString(),
+            });
+          } else {
+            // Self-reflection returned empty — fall back to LLM disposition rewriting
+            log(`[evaluationRunner] Superego self-reflection returned empty, falling back to LLM disposition for turn ${turnIdx + 1}`, 'warn');
+            try {
+              const dispFallback = await promptRewriter.synthesizeSuperegoDisposition({
+                turnResults,
+                consolidatedTrace,
+                conversationHistory,
+                priorSuperegoAssessments,
+                config: rawProfile,
+              });
+              superegoEvolution = dispFallback?.text ?? null;
+            } catch (error) {
+              log(`[evaluationRunner] Superego disposition fallback also failed: ${error.message}`, 'warn');
+            }
+          }
+        } else {
+          const dispResult = group1Map['superego_disposition'];
+          superegoEvolution = dispResult?.text ?? null;
+          if (superegoEvolution) {
+            log(`[evaluationRunner] Superego disposition rewriter generated evolution for turn ${turnIdx + 1}`, 'info');
+            consolidatedTrace.push({
+              agent: 'superego_disposition',
+              action: 'rewrite',
+              turnIndex: turnIdx,
+              contextSummary: `Disposition evolution generated for turn ${turnIdx + 1}`,
+              detail: superegoEvolution,
+              metrics: dispResult?.metrics ?? null,
+              timestamp: new Date().toISOString(),
+            });
+          }
+        }
       }
+
+      // Tutor profile of learner result
+      if (otherEgoProfilingEnabled) {
+        const tutorProfResult = group1Map['tutor_profile'];
+        if (tutorProfResult?.text) {
+          tutorProfileOfLearner = tutorProfResult.text;
+          log(`[evaluationRunner] Tutor profile of learner generated for turn ${turnIdx + 1}`, 'info');
+          consolidatedTrace.push({
+            agent: 'tutor_other_ego',
+            action: 'profile_learner',
+            turnIndex: turnIdx,
+            contextSummary: `Tutor built mental model of learner after turn ${turnIdx + 1}`,
+            detail: tutorProfileOfLearner,
+            metrics: tutorProfResult.metrics ?? null,
+            timestamp: new Date().toISOString(),
+          });
+        }
+      }
+
+      // Learner profile of tutor result
+      if (otherEgoProfilingEnabled && otherEgoBidirectional) {
+        const learnerProfResult = group1Map['learner_profile'];
+        if (learnerProfResult?.text) {
+          learnerProfileOfTutor = learnerProfResult.text;
+          log(`[evaluationRunner] Learner profile of tutor generated for turn ${turnIdx + 1}`, 'info');
+          consolidatedTrace.push({
+            agent: 'learner_other_ego',
+            action: 'profile_tutor',
+            turnIndex: turnIdx,
+            contextSummary: `Learner built mental model of tutor after turn ${turnIdx + 1}`,
+            detail: learnerProfileOfTutor,
+            metrics: learnerProfResult.metrics ?? null,
+            timestamp: new Date().toISOString(),
+          });
+        }
+      }
+
+      // ── Group 2: Dependent on group 1 results ──────────────────────
+      const group2Promises = [];
+      const group2Labels = [];
+
+      // Parse quantitative behavioral parameters (sync — no LLM call)
+      if (quantitativeDispositionEnabled && superegoEvolution) {
+        const parsed = promptRewriter.parseBehavioralParameters(superegoEvolution);
+        if (parsed) {
+          behavioralOverrides = parsed;
+          log(`[evaluationRunner] Behavioral overrides parsed: threshold=${parsed.rejection_threshold}, max_rejections=${parsed.max_rejections}, priority=[${parsed.priority_criteria.join(',')}], deprioritized=[${parsed.deprioritized_criteria.join(',')}]`, 'info');
+          consolidatedTrace.push({
+            agent: 'behavioral_overrides',
+            action: 'parse',
+            turnIndex: turnIdx,
+            contextSummary: `Quantitative behavioral params: threshold=${parsed.rejection_threshold}, max=${parsed.max_rejections}`,
+            detail: JSON.stringify(parsed),
+            timestamp: new Date().toISOString(),
+          });
+        } else {
+          log(`[evaluationRunner] No behavioral parameters found in superego reflection for turn ${turnIdx + 1} (quantitative_disposition enabled but no <behavioral_parameters> block)`, 'warn');
+        }
+      }
+
+      // Intersubjective recognition (depends on ego + superego self-reflections)
+      if (intersubjectiveEnabled && superegoEvolution) {
+        group2Promises.push(
+          promptRewriter.synthesizeEgoResponseToSuperego({
+            superegoReflection: superegoEvolution,
+            egoReflection: sessionEvolution,
+            turnResults,
+            conversationHistory,
+            config: rawProfile,
+          }).catch(error => {
+            log(`[evaluationRunner] Intersubjective ego response failed: ${error.message}`, 'warn');
+            return null;
+          })
+        );
+        group2Labels.push('intersubjective');
+      }
+
+      // Strategy planning (depends on tutor profile)
+      if (strategyPlanningEnabled && tutorProfileOfLearner) {
+        group2Promises.push(
+          promptRewriter.synthesizeStrategyPlan({
+            learnerProfile: tutorProfileOfLearner,
+            turnResults,
+            conversationHistory,
+            config: rawProfile,
+          }).catch(error => {
+            log(`[evaluationRunner] Strategy plan failed: ${error.message}`, 'warn');
+            return null;
+          })
+        );
+        group2Labels.push('strategy');
+      }
+
+      // Fire group 2 in parallel (intersubjective + strategy are independent of each other)
+      if (group2Promises.length > 0) {
+        const group2Results = await Promise.all(group2Promises);
+        const group2Map = {};
+        group2Labels.forEach((label, i) => { group2Map[label] = group2Results[i]; });
+
+        // Process intersubjective result
+        if (group2Map['intersubjective']) {
+          const egoResponseText = group2Map['intersubjective']?.text ?? null;
+          if (egoResponseText) {
+            sessionEvolution = sessionEvolution
+              ? sessionEvolution + '\n\n' + egoResponseText
+              : egoResponseText;
+            log(`[evaluationRunner] Intersubjective ego response to superego generated for turn ${turnIdx + 1}`, 'info');
+            consolidatedTrace.push({
+              agent: 'ego_intersubjective',
+              action: 'respond_to_critic',
+              turnIndex: turnIdx,
+              contextSummary: `Ego responded to superego's self-reflection for turn ${turnIdx + 1}`,
+              detail: egoResponseText,
+              metrics: group2Map['intersubjective']?.metrics ?? null,
+              timestamp: new Date().toISOString(),
+            });
+          }
+        }
+
+        // Process strategy plan result
+        if (group2Map['strategy']) {
+          strategyPlan = group2Map['strategy']?.text ?? null;
+          if (strategyPlan) {
+            log(`[evaluationRunner] Strategy plan generated for turn ${turnIdx + 1}`, 'info');
+            consolidatedTrace.push({
+              agent: 'ego_strategy',
+              action: 'plan',
+              turnIndex: turnIdx,
+              contextSummary: `Ego formulated strategy plan for turn ${turnIdx + 1}`,
+              detail: strategyPlan,
+              metrics: group2Map['strategy']?.metrics ?? null,
+              timestamp: new Date().toISOString(),
+            });
+          }
+        }
+      }
+
+      const betweenTurnMs = Date.now() - betweenTurnStart;
+      log(`[evaluationRunner] Between-turn processing completed in ${(betweenTurnMs / 1000).toFixed(1)}s (${group1Labels.length} parallel group-1, ${group2Labels.length} parallel group-2)`, 'info');
     }
 
+    // Flush transcript: reflections (self-reflection, disposition, profiling, etc.)
+    flushTranscript();
+
     // Generate LLM learner response for next turn if ego_superego architecture
     // Note: check includes() to handle both 'ego_superego' and 'ego_superego_recognition'
     if (resolvedConfig.learnerArchitecture?.includes('ego_superego') && turnIdx < totalTurnCount - 1) {
@@ -1595,7 +2434,10 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
           })),
           learnerProfile: resolvedConfig.learnerArchitecture,
           personaId: fullScenario.learner_persona || 'eager_novice',
-          modelOverride: config.modelOverride || null,
+          modelOverride: config.learnerModelOverride || config.modelOverride || null,
+          profileContext: (otherEgoBidirectional && learnerProfileOfTutor)
+            ? promptRewriter.formatProfileForInjection(learnerProfileOfTutor, 'tutor')
+            : null,
         });
 
         // Override scripted message with LLM-generated one
@@ -1633,10 +2475,32 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
         }
 
         log(`[evaluationRunner] Generated LLM learner response (ego_superego): "${learnerResponse.message.substring(0, 80)}..."`, 'info');
+
+        // Flush transcript: learner deliberation
+        flushTranscript();
       }
     }
   }
 
+  // Clear turn progress from run metadata now that all turns are complete
+  if (runId) {
+    evaluationStore.updateRun(runId, {
+      metadata: { turnProgress: null }
+    });
+  }
+
+  // Write complete transcript file at end (for post-hoc viewing)
+  if (transcriptMode && transcriptPath) {
+    const fullTranscript = formatTranscript(consolidatedTrace, {
+      detail: 'play',
+      scenarioName: fullScenario.name || scenario.id,
+      profileName: config.profileName,
+      totalTurns: turnResults.length,
+    });
+    fs.writeFileSync(transcriptPath, fullTranscript);
+    log(`[evaluationRunner] Transcript written: ${transcriptPath}`, 'info');
+  }
+
   // 5. Aggregate scores across turns
   const validTurnScores = turnResults.filter(t => t.turnScore !== null).map(t => t.turnScore);
   const overallScore = validTurnScores.length > 0
@@ -1792,7 +2656,7 @@ async function runMultiTurnTest(scenario, config, fullScenario, options = {}) {
     superegoModel: resolvedConfig.superegoModel
       ? `${resolvedConfig.superegoModel.provider}.${resolvedConfig.superegoModel.model}`
       : null,
-    hyperparameters: config.hyperparameters,
+    hyperparameters: resolvedConfig.hyperparameters || config.hyperparameters,
     suggestions: turnResults.map(t => t.suggestion).filter(Boolean),
     success: true,
     latencyMs: totalLatencyMs,
@@ -1876,6 +2740,7 @@ export async function resumeEvaluation(options = {}) {
   const runsPerConfig = metadata.runsPerConfig || 1;
   const skipRubricEval = metadata.skipRubricEval || false;
   const modelOverride = metadata.modelOverride || null;
+  const learnerModelOverride = metadata.learnerModelOverride || null;
 
   // 3. Get existing results for completion checking
   const existingResults = evaluationStore.getResults(runId);
@@ -1917,10 +2782,13 @@ export async function resumeEvaluation(options = {}) {
     label: name,
   }));
 
-  // 6. Re-apply modelOverride if present in metadata
+  // 6. Re-apply model overrides if present in metadata
   if (modelOverride) {
     targetConfigs = targetConfigs.map(c => ({ ...c, modelOverride }));
   }
+  if (learnerModelOverride) {
+    targetConfigs = targetConfigs.map(c => ({ ...c, learnerModelOverride }));
+  }
 
   // 6. Count successful results per (profile, scenario) combo and fill up to runsPerConfig.
   //    Failed results are excluded so they get retried.
@@ -1971,6 +2839,7 @@ export async function resumeEvaluation(options = {}) {
   console.log(`  Profiles: ${profileNames.join(', ')}`);
   console.log(`  Scenarios: ${targetScenarios.length}`);
   if (modelOverride) console.log(`  Model override: ${modelOverride}`);
+  if (learnerModelOverride) console.log(`  Learner model override: ${learnerModelOverride}`);
 
   // Initialize content resolver (same as runEvaluation)
   const contentConfig = evalConfigLoader.getContentConfig();
@@ -2128,29 +2997,36 @@ export async function resumeEvaluation(options = {}) {
       completedTests++;
       log(`  ${formatProgress(completedTests, totalRemainingTests, runStartTime)} ${profileLabel} / ${scenario.id}: ERROR - ${error.message}`);
 
-      // Store failed result so it shows up in the database
-      const failedResult = {
-        scenarioId: scenario.id,
-        scenarioName: scenario.name || scenario.id,
-        profileName: config.profileName,
-        provider: config.provider || config.ego?.provider || 'unknown',
-        model: config.model || config.ego?.model || 'unknown',
-        egoModel: config.egoModel
-          ? `${config.egoModel.provider}.${config.egoModel.model}`
-          : config.ego ? `${config.ego.provider}.${config.ego.model}` : null,
-        superegoModel: config.superegoModel
-          ? `${config.superegoModel.provider}.${config.superegoModel.model}`
-          : config.superego ? `${config.superego.provider}.${config.superego.model}` : null,
-        factors: config.factors || null,
-        learnerArchitecture: config.learnerArchitecture || null,
-        success: false,
-        errorMessage: error.message,
-      };
-      try {
-        evaluationStore.storeResult(runId, failedResult);
-        results.push(failedResult);
-      } catch (storeErr) {
-        log(`  [WARNING] Failed to store error result: ${storeErr.message}`);
+      // Only store failed results for permanent errors — skip transient/retriable ones
+      const errMsg = error.message || '';
+      const isTransient = /429|rate limit|too many requests|503|502|timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|terminated|unavailable|failed to generate suggestions/i.test(errMsg);
+
+      if (!isTransient) {
+        const failedResult = {
+          scenarioId: scenario.id,
+          scenarioName: scenario.name || scenario.id,
+          profileName: config.profileName,
+          provider: config.provider || config.ego?.provider || 'unknown',
+          model: config.model || config.ego?.model || 'unknown',
+          egoModel: config.egoModel
+            ? `${config.egoModel.provider}.${config.egoModel.model}`
+            : config.ego ? `${config.ego.provider}.${config.ego.model}` : null,
+          superegoModel: config.superegoModel
+            ? `${config.superegoModel.provider}.${config.superegoModel.model}`
+            : config.superego ? `${config.superego.provider}.${config.superego.model}` : null,
+          factors: config.factors || null,
+          learnerArchitecture: config.learnerArchitecture || null,
+          success: false,
+          errorMessage: error.message,
+        };
+        try {
+          evaluationStore.storeResult(runId, failedResult);
+          results.push(failedResult);
+        } catch (storeErr) {
+          log(`  [WARNING] Failed to store error result: ${storeErr.message}`);
+        }
+      } else {
+        log(`  [SKIPPED] Transient error, not storing empty row (resumable): ${errMsg.substring(0, 100)}`);
       }
 
       progressLogger.testError({
@@ -2287,6 +3163,7 @@ export async function quickTest(config, options = {}) {
     onLog,
     superegoStrategy = null, // Superego intervention strategy
     judgeOverride = null, // Override judge model for this run
+    dryRun = false,
   } = options;
 
   const scenarios = [evalConfigLoader.listScenarios().find(s => s.id === scenarioId)].filter(Boolean);
@@ -2294,7 +3171,7 @@ export async function quickTest(config, options = {}) {
     throw new Error(`Scenario not found: ${scenarioId}`);
   }
 
-  const result = await runSingleTest(scenarios[0], config, { verbose, skipRubricEval, outputSize, onLog, superegoStrategy, judgeOverride });
+  const result = await runSingleTest(scenarios[0], config, { verbose, skipRubricEval, outputSize, onLog, superegoStrategy, judgeOverride, dryRun });
   return result;
 }