@forwardimpact/libeval 0.1.14 → 0.1.16

package/src/supervisor.js

@@ -4,50 +4,37 @@
  * introduces itself, and delegates work to the agent. The loop then alternates:
  * agent → supervisor → agent.
  *
+ * Signaling uses orchestration tools (Conclude, Redirect, Ask) via in-process
+ * MCP servers. No text-token detection.
+ *
  * Follows OO+DI: constructor injection, factory function, tests bypass factory.
  */
 
-import { PassThrough } from "node:stream";
+import { Writable } from "node:stream";
 import { createAgentRunner } from "./agent-runner.js";
 import { TraceCollector } from "./trace-collector.js";
-
-/**
- * Check if the supervisor's response signals evaluation success.
- * Matches EVALUATION_COMPLETE anywhere in the text, tolerating markdown
- * formatting (e.g. **EVALUATION_COMPLETE**). Uses word boundaries to
- * avoid matching inside longer identifiers.
- * @param {string} text
- * @returns {boolean}
- */
-export function isComplete(text) {
-  return /(?:^|[\s*_~`])EVALUATION_COMPLETE(?:[\s*_~`.,!?]|$)/m.test(text);
-}
-
-/**
- * Check if the supervisor's response signals a mid-turn intervention.
- * Same tolerance rules as isComplete (markdown formatting, word boundaries),
- * but matches the EVALUATION_INTERVENTION keyword instead.
- * @param {string} text
- * @returns {boolean}
- */
-export function isIntervention(text) {
-  return /(?:^|[\s*_~`])EVALUATION_INTERVENTION(?:[\s*_~`.,!?]|$)/m.test(text);
-}
+import { SequenceCounter } from "./sequence-counter.js";
+import {
+  createOrchestrationContext,
+  createSupervisorToolServer,
+  createSupervisedAgentToolServer,
+} from "./orchestration-toolkit.js";
 
 /** System prompt appended for the supervisor runner in supervise mode. */
 export const SUPERVISOR_SYSTEM_PROMPT =
   "You relay messages to one persistent agent session — your only output " +
   "channel. Spawning sub-agents or restarting the agent is blocked. Do not " +
-  "do the work yourself. Reply briefly to let the agent continue, write " +
-  "EVALUATION_INTERVENTION + instructions to interrupt mid-turn, or " +
-  "EVALUATION_COMPLETE when done. Only your final message each turn is " +
-  "relayed.";
+  "do the work yourself. Reply briefly to let the agent continue. Use your " +
+  "Redirect tool to interrupt and correct the agent. Use your Conclude tool " +
+  "with a summary when the task is fully done. Only your final message each " +
+  "turn is relayed.";
 
 /** System prompt appended for the agent runner in supervise mode. */
 export const AGENT_SYSTEM_PROMPT =
   "A supervisor watches your work and may interrupt with new instructions " +
   "mid-task. Treat any new prompt as authoritative and adjust course. " +
-  "When uncertain, stop and ask a clarifying question.";
+  "When uncertain, use your Ask tool to ask the supervisor a clarifying " +
+  "question — you will receive a direct answer.";
 
 /**
  * Maximum number of mid-turn interventions allowed within a single agent turn.
@@ -64,8 +51,9 @@ export class Supervisor {
    * @param {import("./agent-runner.js").AgentRunner} deps.supervisorRunner - Runs the supervisor sessions
    * @param {import("stream").Writable} deps.output - Stream to emit tagged NDJSON to
    * @param {number} [deps.maxTurns] - Maximum supervisor ↔ agent exchanges
+   * @param {object} [deps.ctx] - Orchestration context (injected by factory)
    */
-  constructor({ agentRunner, supervisorRunner, output, maxTurns }) {
+  constructor({ agentRunner, supervisorRunner, output, maxTurns, ctx }) {
     if (!agentRunner) throw new Error("agentRunner is required");
     if (!supervisorRunner) throw new Error("supervisorRunner is required");
     if (!output) throw new Error("output is required");
@@ -73,51 +61,22 @@ export class Supervisor {
     this.supervisorRunner = supervisorRunner;
     this.output = output;
     this.maxTurns = maxTurns ?? 100;
+    this.ctx = ctx ?? createOrchestrationContext();
+    this.counter = new SequenceCounter();
     /** @type {"agent"|"supervisor"} */
     this.currentSource = "agent";
     /** @type {number} */
     this.currentTurn = 0;
-    /**
-     * Set to true when any supervisor message contains the success signal.
-     * The SDK result text only reflects the last assistant message, so when
-     * the supervisor writes EVALUATION_COMPLETE in an early message and
-     * then continues with follow-up work, the result text won't contain it.
-     * This flag captures the signal from the full message stream.
-     * @type {boolean}
-     */
-    this.completeSignalSeen = false;
-    /**
-     * Set to true when any supervisor message contains EVALUATION_INTERVENTION.
-     * Mirrors completeSignalSeen — populated by emitLine when a supervisor
-     * assistant text block matches isIntervention(...). The mid-turn loop
-     * reads this flag after each supervisor invocation to decide whether to
-     * abort the agent's in-flight SDK session.
-     * @type {boolean}
-     */
-    this.interventionSignalSeen = false;
-    /**
-     * The most recent supervisor SDK result captured inside the mid-turn
-     * onBatch callback. The outer loop reads this after the agent aborts to
-     * build the next relay prompt without re-running the supervisor.
-     * @type {{success: boolean, text: string}|null}
-     */
-    this.lastSupervisorResult = null;
   }
 
   /**
    * Run the supervisor ↔ agent relay loop.
-   * The supervisor receives the task first, introduces itself, and delegates
-   * work to the agent. The loop then alternates: agent → supervisor → agent.
    * @param {string} task - The initial task for the supervisor
    * @returns {Promise<{success: boolean, turns: number}>}
    */
   async run(task) {
-    // Turn 0: Supervisor receives the task and introduces it to the agent
     this.currentSource = "supervisor";
     this.currentTurn = 0;
-    this.completeSignalSeen = false;
-    this.interventionSignalSeen = false;
-    this.lastSupervisorResult = null;
     let supervisorResult = await this.supervisorRunner.run(task);
 
     if (supervisorResult.error) {
@@ -125,38 +84,25 @@ export class Supervisor {
       return { success: false, turns: 0 };
     }
 
-    // Check for the success signal in either the SDK result text or the
-    // streamed message content. The SDK result text only reflects the last
-    // assistant message, so when the supervisor writes EVALUATION_COMPLETE
-    // early and then continues (e.g. filing issues), we must also check the
-    // flag set by emitLine during streaming.
-    if (this.completeSignalSeen || isComplete(supervisorResult.text)) {
-      this.emitSummary({ success: true, turns: 0 });
+    if (this.ctx.concluded) {
+      this.emitSummary({ success: true, turns: 0, summary: this.ctx.summary });
       return { success: true, turns: 0 };
     }
 
+    let pendingRelay = null;
     const turnLimit = this.maxTurns === 0 ? Infinity : this.maxTurns;
     for (let turn = 1; turn <= turnLimit; turn++) {
-      // Only the supervisor's final message is relayed to the agent.
-      // Extract the last assistant text block from the buffer to avoid
-      // leaking intermediate reasoning (research, tool calls, notes).
-      const relay = this.extractLastText(
-        this.supervisorRunner,
-        supervisorResult.text,
-      );
+      const relay =
+        pendingRelay ??
+        this.extractLastText(this.supervisorRunner, supervisorResult.text);
 
-      // Drive the agent through interventions until its SDK session ends
-      // naturally, the supervisor signals completion mid-turn, or the
-      // per-turn intervention budget is exhausted.
       const turnOutcome = await this.#runAgentTurn(turn, relay);
       if (turnOutcome.exit) return turnOutcome.exit;
 
-      // End-of-turn review (existing behaviour). Returns either an exit
-      // outcome (error or completion) or the supervisor result for the
-      // next turn's relay.
       const reviewOutcome = await this.#endOfTurnReview(turn);
       if (reviewOutcome.exit) return reviewOutcome.exit;
       supervisorResult = reviewOutcome.supervisorResult;
+      pendingRelay = reviewOutcome.relay ?? null;
     }
 
     this.emitSummary({ success: false, turns: this.maxTurns });
@@ -165,9 +111,8 @@ export class Supervisor {
 
   /**
    * Drive the agent through one turn, allowing the supervisor to interrupt
-   * mid-stream via EVALUATION_INTERVENTION. Returns either an `exit` outcome
-   * (the loop should return immediately) or `{exit: null}` (proceed to the
-   * end-of-turn review).
+   * via the Redirect tool. Returns either an `exit` outcome (the loop should
+   * return immediately) or `{exit: null}` (proceed to end-of-turn review).
    * @param {number} turn
    * @param {string} initialRelay
    * @returns {Promise<{exit: {success: boolean, turns: number}|null}>}
@@ -176,11 +121,6 @@ export class Supervisor {
     let relay = initialRelay;
     let interventions = 0;
 
-    // Wire the mid-turn observation hook on the agent runner. The bound
-    // callback captures `turn` so the inner loop's multiple resume(...)
-    // calls all see the same turn id. The supervisorRunner does NOT get
-    // an onBatch callback — it only fires onLine, which is enough for
-    // emitLine to detect EVALUATION_COMPLETE / EVALUATION_INTERVENTION.
     this.agentRunner.onBatch = (batchLines, ctx) =>
       this.#midTurnReview(turn, batchLines, ctx);
 
@@ -198,124 +138,109 @@ export class Supervisor {
           return { exit: { success: false, turns: turn } };
         }
 
-        // Mid-turn EVALUATION_COMPLETE: end the session immediately.
-        if (this.completeSignalSeen) {
-          this.emitSummary({ success: true, turns: turn });
+        if (this.ctx.concluded) {
+          this.emitSummary({
+            success: true,
+            turns: turn,
+            summary: this.ctx.summary,
+          });
           return { exit: { success: true, turns: turn } };
         }
 
-        if (agentResult.aborted && this.interventionSignalSeen) {
+        if (agentResult.aborted && this.ctx.redirect) {
           interventions++;
+          const redirect = this.ctx.redirect;
+          this.ctx.redirect = null;
           if (interventions >= MAX_INTERVENTIONS_PER_TURN) {
             this.emitOrchestratorEvent({ type: "intervention_limit", turn });
             return { exit: null };
           }
-          relay = this.extractLastText(
-            this.supervisorRunner,
-            this.lastSupervisorResult?.text ?? "",
-          );
+          relay = redirect.message;
           this.emitOrchestratorEvent({ type: "intervention_relayed", turn });
           continue;
         }
 
-        // Agent's SDK session finished naturally — proceed to end-of-turn.
         return { exit: null };
       }
     } finally {
-      // Detach onBatch before the end-of-turn review so the supervisor's
-      // own SDK session does not trigger nested onBatch fires.
       this.agentRunner.onBatch = null;
     }
   }
 
   /**
    * Mid-turn supervisor review fired from inside the agent's onBatch hook.
-   * Emits a `mid_turn_review` orchestrator marker, runs the supervisor's
-   * LLM against the batch, and aborts the agent if the supervisor signals
-   * EVALUATION_INTERVENTION or EVALUATION_COMPLETE.
+   * Runs the supervisor's LLM against the batch and aborts the agent if
+   * the supervisor calls Redirect or Conclude.
    * @param {number} turn
    * @param {string[]} batchLines
    * @param {{abort: () => void}} ctx
    */
   async #midTurnReview(turn, batchLines, { abort }) {
     const batchTranscript = this.renderBatch(batchLines);
-
-    // Order matters: emit the orchestrator marker BEFORE the supervisor
-    // LLM call so the trace reads
-    //   agent line → orchestrator:mid_turn_review
-    //   → supervisor lines (tagged turn:N)
-    //   → orchestrator:intervention_requested|complete_requested
     this.emitOrchestratorEvent({ type: "mid_turn_review", turn });
 
-    // currentTurn stays = turn so mid-turn supervisor lines share the
-    // agent's turn id. They are distinguishable from end-of-turn reviews
-    // by the surrounding orchestrator events emitted around this call.
     this.currentSource = "supervisor";
-    this.completeSignalSeen = false;
-    this.interventionSignalSeen = false;
+    this.ctx.redirect = null;
 
-    this.lastSupervisorResult = await this.supervisorRunner.resume(
+    await this.supervisorRunner.resume(
       `The agent is mid-turn. Latest batch:\n\n${batchTranscript}\n\n` +
-        `Respond with a brief acknowledgement to let it continue, or write ` +
-        `EVALUATION_INTERVENTION followed by a corrective message to stop ` +
-        `and relay a new instruction. Write EVALUATION_COMPLETE only when ` +
-        `the task is fully done.`,
+        `Review and use your tools if action is needed.`,
     );
     this.currentSource = "agent";
 
-    if (this.interventionSignalSeen) {
+    if (this.ctx.redirect) {
       this.emitOrchestratorEvent({ type: "intervention_requested", turn });
       abort();
       return;
     }
-    if (this.completeSignalSeen) {
+    if (this.ctx.concluded) {
       this.emitOrchestratorEvent({ type: "complete_requested", turn });
       abort();
     }
-    // Non-intervention: do nothing; the agent loop pulls the next line.
   }
 
   /**
-   * End-of-turn supervisor review (existing behaviour). Returns either an
-   * exit outcome (error or completion) or the supervisor result so the
-   * outer loop can build the next turn's relay.
+   * End-of-turn supervisor review. Returns either an exit outcome (error or
+   * completion) or the supervisor result so the outer loop can build the
+   * next turn's relay.
    * @param {number} turn
-   * @returns {Promise<{exit: {success: boolean, turns: number}|null, supervisorResult?: object}>}
+   * @returns {Promise<{exit: {success: boolean, turns: number}|null, supervisorResult?: object, relay?: string}>}
    */
   async #endOfTurnReview(turn) {
-    // Build the full agent transcript from buffered NDJSON events so the
-    // supervisor sees tool calls and reasoning, not just the SDK result.
     const agentTranscript = this.extractTranscript(this.agentRunner);
-
-    const supervisorPrompt =
-      `The agent reported:\n\n${agentTranscript}\n\n` +
-      `Review the agent's work and decide how to proceed.`;
-
     this.currentSource = "supervisor";
     this.currentTurn = turn;
-    this.completeSignalSeen = false;
-    this.interventionSignalSeen = false;
-    const supervisorResult =
-      await this.supervisorRunner.resume(supervisorPrompt);
+    this.ctx.redirect = null;
+
+    const supervisorResult = await this.supervisorRunner.resume(
+      `The agent reported:\n\n${agentTranscript}\n\nReview the agent's work and decide how to proceed.`,
+    );
 
     if (supervisorResult.error) {
       this.emitSummary({ success: false, turns: turn });
       return { exit: { success: false, turns: turn } };
     }
 
-    // The supervisor's turn is fully complete — check for success signal
-    // in either the SDK result text or streamed messages.
-    if (this.completeSignalSeen || isComplete(supervisorResult.text)) {
-      this.emitSummary({ success: true, turns: turn });
+    if (this.ctx.concluded) {
+      this.emitSummary({
+        success: true,
+        turns: turn,
+        summary: this.ctx.summary,
+      });
       return { exit: { success: true, turns: turn } };
     }
 
+    if (this.ctx.redirect) {
+      const redirect = this.ctx.redirect;
+      this.ctx.redirect = null;
+      return { exit: null, supervisorResult, relay: redirect.message };
+    }
+
     return { exit: null, supervisorResult };
   }
 
   /**
    * Extract a human-readable transcript from an AgentRunner's buffered output.
-   * Drains the buffer and replays events through a TraceCollector.
    * @param {import("./agent-runner.js").AgentRunner} runner
    * @returns {string}
    */
@@ -330,11 +255,8 @@ export class Supervisor {
 
   /**
    * Extract only the last assistant text block from an AgentRunner's buffer.
-   * Scans buffered NDJSON events in reverse to find the final assistant message
-   * with a text content block. This prevents intermediate reasoning (tool calls,
-   * research notes) from leaking to the agent.
    * @param {import("./agent-runner.js").AgentRunner} runner
-   * @param {string} fallback - Fallback text if no assistant text block is found
+   * @param {string} fallback
    * @returns {string}
    */
   extractLastText(runner, fallback) {
@@ -354,43 +276,21 @@ export class Supervisor {
   }
 
   /**
-   * Emit a single NDJSON line tagged with the current source and turn.
-   * Called in real-time via the AgentRunner onLine callback.
-   *
-   * When the current source is the supervisor, also scans assistant text
-   * content for the EVALUATION_COMPLETE and EVALUATION_INTERVENTION signals,
-   * setting completeSignalSeen / interventionSignalSeen respectively.
+   * Emit a single NDJSON line tagged with the current source and seq.
    * @param {string} line - Raw NDJSON line from the runner
    */
   emitLine(line) {
     const event = JSON.parse(line);
     const tagged = {
       source: this.currentSource,
-      turn: this.currentTurn,
+      seq: this.counter.next(),
       event,
     };
     this.output.write(JSON.stringify(tagged) + "\n");
-
-    // Scan supervisor assistant messages for the signals in real time.
-    // The SDK result text only reflects the final assistant message, but the
-    // supervisor may write EVALUATION_COMPLETE / EVALUATION_INTERVENTION in
-    // an earlier message and then continue with follow-up tool calls.
-    if (this.currentSource === "supervisor" && event.type === "assistant") {
-      const content = event.message?.content ?? event.content ?? [];
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block.type !== "text" || !block.text) continue;
-          if (isComplete(block.text)) this.completeSignalSeen = true;
-          if (isIntervention(block.text)) this.interventionSignalSeen = true;
-        }
-      }
-    }
   }
 
   /**
-   * Render a batch of buffered NDJSON lines as human-readable text for the
-   * mid-turn supervisor prompt. Reuses the TraceCollector pipeline so the
-   * supervisor sees tool calls and reasoning, not just raw events.
+   * Render a batch of buffered NDJSON lines as human-readable text.
    * @param {string[]} batchLines
    * @returns {string}
    */
@@ -404,53 +304,59 @@ export class Supervisor {
   }
 
   /**
-   * Emit an orchestrator-source NDJSON line. Used by the mid-turn loop to
-   * mark mid_turn_review / intervention_requested / intervention_relayed /
-   * intervention_limit / complete_requested boundaries in the trace, so the
-   * improvement coach can distinguish mid-turn supervisor activity from
-   * end-of-turn reviews. Additive to existing trace shape — the parser
-   * already reads `source` and ignores unknown event types.
+   * Emit an orchestrator-source NDJSON line.
    * @param {{type: string, turn?: number}} event
    */
   emitOrchestratorEvent(event) {
     this.output.write(
       JSON.stringify({
         source: "orchestrator",
-        turn: this.currentTurn,
+        seq: this.counter.next(),
         event,
       }) + "\n",
     );
   }
 
   /**
-   * Emit a final orchestrator summary line.
-   * @param {{success: boolean, turns: number}} result
+   * Emit a final orchestrator summary line, wrapped in the universal envelope.
+   * @param {{success: boolean, turns: number, summary?: string}} result
    */
   emitSummary(result) {
-    const summary = {
-      source: "orchestrator",
-      type: "summary",
-      success: result.success,
-      turns: result.turns,
-    };
-    this.output.write(JSON.stringify(summary) + "\n");
+    this.output.write(
+      JSON.stringify({
+        source: "orchestrator",
+        seq: this.counter.next(),
+        event: {
+          type: "summary",
+          success: result.success,
+          turns: result.turns,
+          ...(result.summary && { summary: result.summary }),
+        },
+      }) + "\n",
+    );
   }
 }
 
+const devNull = new Writable({
+  write(_chunk, _enc, cb) {
+    cb();
+  },
+});
+
 /**
  * Factory function — wires both AgentRunners with their respective configs.
  * @param {object} deps
- * @param {string} deps.supervisorCwd - Supervisor working directory
- * @param {string} deps.agentCwd - Agent working directory
- * @param {function} deps.query - SDK query function
- * @param {import("stream").Writable} deps.output - Final output stream
- * @param {string} [deps.model] - Claude model identifier
- * @param {number} [deps.maxTurns] - Maximum supervisor ↔ agent exchanges
- * @param {string[]} [deps.allowedTools] - Tools the agent may use
- * @param {string[]} [deps.supervisorAllowedTools] - Tools the supervisor may use (default: Bash, Read, Glob, Grep, Write, Edit)
- * @param {string[]} [deps.supervisorDisallowedTools] - Tools to explicitly block from the supervisor
- * @param {string} [deps.supervisorProfile] - Supervisor agent profile name
- * @param {string} [deps.agentProfile] - Agent profile name
+ * @param {string} deps.supervisorCwd
+ * @param {string} deps.agentCwd
+ * @param {function} deps.query
+ * @param {import("stream").Writable} deps.output
+ * @param {string} [deps.model]
+ * @param {number} [deps.maxTurns]
+ * @param {string[]} [deps.allowedTools]
+ * @param {string[]} [deps.supervisorAllowedTools]
+ * @param {string[]} [deps.supervisorDisallowedTools]
+ * @param {string} [deps.supervisorProfile]
+ * @param {string} [deps.agentProfile]
  * @returns {Supervisor}
  */
 export function createSupervisor({
@@ -466,15 +372,31 @@ export function createSupervisor({
   supervisorProfile,
   agentProfile,
 }) {
-  // Forward-reference: onLine captures `supervisor` before construction completes.
-  // This is safe because onLine is only called during run(), after construction.
   let supervisor;
+  let supervisorRunner;
+
+  const ctx = createOrchestrationContext();
+
+  const supervisorServer = createSupervisorToolServer(ctx);
+  const agentServer = createSupervisedAgentToolServer(ctx, {
+    onAsk: async (question) => {
+      supervisor.currentSource = "supervisor";
+      supervisor.emitOrchestratorEvent({ type: "ask_received" });
+      await supervisorRunner.resume(
+        `The agent asks: "${question}"\n\nAnswer the question directly.`,
+      );
+      supervisor.currentSource = "agent";
+      supervisor.emitOrchestratorEvent({ type: "ask_answered" });
+      return supervisor.extractLastText(supervisorRunner, "No answer.");
+    },
+  });
+
   const onLine = (line) => supervisor.emitLine(line);
 
   const agentRunner = createAgentRunner({
     cwd: agentCwd,
     query,
-    output: new PassThrough(),
+    output: devNull,
     model,
     maxTurns: 50,
     allowedTools,
@@ -486,24 +408,18 @@ export function createSupervisor({
       preset: "claude_code",
       append: AGENT_SYSTEM_PROMPT,
     },
+    mcpServers: { orchestration: agentServer },
   });
 
-  // Block every sub-agent spawning tool so the supervisor cannot bypass the
-  // relay loop. The current Claude Agent SDK exposes the spawn tool to the
-  // model as `Agent`; older versions called it `Task`. Both are blocked
-  // (along with TaskOutput/TaskStop) so the supervisor sees no spawn tool
-  // regardless of which SDK version is installed. Letting the supervisor
-  // spawn its own sub-agent would bypass the relay and produce an empty
-  // agent trace, which is the failure mode that motivated this default.
   const defaultDisallowed = ["Agent", "Task", "TaskOutput", "TaskStop"];
   const disallowedTools = supervisorDisallowedTools
     ? [...new Set([...defaultDisallowed, ...supervisorDisallowedTools])]
     : defaultDisallowed;
 
-  const supervisorRunner = createAgentRunner({
+  supervisorRunner = createAgentRunner({
     cwd: supervisorCwd,
     query,
-    output: new PassThrough(),
+    output: devNull,
     model,
     maxTurns: 20,
     allowedTools: supervisorAllowedTools ?? [
@@ -523,6 +439,7 @@ export function createSupervisor({
       preset: "claude_code",
       append: SUPERVISOR_SYSTEM_PROMPT,
     },
+    mcpServers: { orchestration: supervisorServer },
   });
 
   supervisor = new Supervisor({
@@ -530,6 +447,7 @@ export function createSupervisor({
     supervisorRunner,
     output,
     maxTurns,
+    ctx,
   });
   return supervisor;
 }

package/src/tee-writer.js

@@ -3,9 +3,9 @@
  * simultaneously streaming human-readable text to a separate stream (e.g.
  * process.stdout).
  *
- * Supports two modes:
- * - "raw" (default): expects standard stream-json events from AgentRunner
- * - "supervised": expects tagged events {source, turn, event} from Supervisor
+ * All modes emit the same { source, seq, event } envelope. The `mode`
+ * parameter controls display formatting: multi-participant modes show
+ * source labels on content lines.
  *
  * Follows OO+DI: constructor injection, factory function, tests bypass factory.
  */
@@ -18,7 +18,7 @@ export class TeeWriter extends Writable {
    * @param {object} deps
    * @param {import("stream").Writable} deps.fileStream - Stream to write raw NDJSON to
    * @param {import("stream").Writable} deps.textStream - Stream to write human-readable text to
-   * @param {"raw"|"supervised"} [deps.mode] - Event format: "raw" or "supervised" (default: "raw")
+   * @param {"raw"|"supervised"} [deps.mode] - Display mode: "raw" (no source labels) or "supervised" (source labels) (default: "raw")
    */
   constructor({ fileStream, textStream, mode }) {
     super();
@@ -72,23 +72,10 @@ export class TeeWriter extends Writable {
   }
 
   /**
-   * Process a single NDJSON line — feed to collector and flush text.
+   * Process a single NDJSON line — unified envelope handling for all modes.
    * @param {string} line
    */
   processLine(line) {
-    if (this.mode === "supervised") {
-      this.processSupervisedLine(line);
-    } else {
-      this.collector.addLine(line);
-      this.flushTurns();
-    }
-  }
-
-  /**
-   * Handle a tagged supervisor line: unwrap event, show source labels.
-   * @param {string} line
-   */
-  processSupervisedLine(line) {
     let parsed;
     try {
       parsed = JSON.parse(line);
@@ -96,21 +83,28 @@ export class TeeWriter extends Writable {
       return;
     }
 
-    if (parsed.source === "orchestrator" && parsed.type === "summary") {
-      const status = parsed.success ? "completed" : "incomplete";
-      this.textStream.write(
-        `\n--- Evaluation ${status} after ${parsed.turns} turns ---\n`,
-      );
-      return;
-    }
-
+    // Universal envelope: { source, seq, event }
     if (parsed.event) {
+      // Orchestrator summary event
+      if (parsed.source === "orchestrator" && parsed.event.type === "summary") {
+        const status = parsed.event.success ? "completed" : "incomplete";
+        this.textStream.write(
+          `\n--- Evaluation ${status} after ${parsed.event.turns} turns ---\n`,
+        );
+        return;
+      }
+
       if (parsed.source && parsed.source !== this.lastSource) {
         this.lastSource = parsed.source;
       }
       this.collector.addLine(JSON.stringify(parsed.event));
       this.flushTurns();
+      return;
     }
+
+    // Bare event (run mode pre-migration or direct feed)
+    this.collector.addLine(line);
+    this.flushTurns();
   }
 
   /**