@forwardimpact/libeval 0.1.43 → 0.1.45

package/src/facilitator.js

@@ -1,379 +1,72 @@
 /**
- * Facilitator — N agent sessions + one facilitator LLM session. The Ask/Answer
- * contract is enforced at turn boundaries via checkPendingAsk: one synthetic
- * reminder, then a `protocol_violation` event plus a null-answer injection so
- * the session advances instead of deadlocking.
+ * Facilitator — facilitate-mode wrapper around `OrchestrationLoop`. The
+ * lead participant is named "facilitator" and ends the session via the
+ * `Conclude` tool. The within-run turn loop lives in
+ * `orchestration-loop.js`; this file owns only the facilitate-mode
+ * specifics (lead role name, system prompts, tool wiring, factory).
  */
 
 import { Writable } from "node:stream";
 import { resolve } from "node:path";
 import { createAgentRunner } from "./agent-runner.js";
 import { composeProfilePrompt } from "./profile-prompt.js";
-import { SequenceCounter } from "./sequence-counter.js";
 import { createMessageBus } from "./message-bus.js";
 import {
   createOrchestrationContext,
   createFacilitatorToolServer,
   createFacilitatedAgentToolServer,
-  checkPendingAsk,
 } from "./orchestration-toolkit.js";
-import { createAsyncQueue, formatMessages } from "./orchestrator-helpers.js";
+import { OrchestrationLoop } from "./orchestration-loop.js";
 
 /** System prompt appended for the facilitator runner. */
 export const FACILITATOR_SYSTEM_PROMPT =
-  "You coordinate multiple participants. " +
-  "Ask sends a question to a participant; omit the addressee to broadcast. " +
-  "Announce sends a message with no reply obligation. " +
-  "Redirect interrupts a participant with replacement instructions. " +
-  "RollCall lists participants. " +
-  "Conclude ends the session with a verdict ('success' or 'failure') and a summary; " +
-  "the verdict reflects whether the session met the criteria stated in the task.";
+  "You coordinate multiple participants via these tools: " +
+  "Ask sends a question and returns immediately with {askIds:[N,…]}. The reply arrives on a later turn as `[answer#N] <participant>: <text>` in your inbox — between turns you can plan, reflect, or send more Asks while participants work in parallel. End your turn with text after you've asked everything you intend to; the orchestrator wakes you again as soon as a reply (or any message) lands. " +
+  "Answer replies to an ask a participant addressed to you (you'll see it tagged `[ask#N] <participant>: …` in your inbox). Quote askId from the [ask#N] tag; omit it and the handler auto-picks the only pending ask or routes your message as an Announce. " +
+  "Announce delivers a message with no reply obligation. " +
+  "RollCall returns the participant roster. " +
+  "Conclude ends the session with a verdict ('success' or 'failure') and a summary. " +
+  "Multiple Ask / Announce calls in one assistant turn dispatch in parallel — issue them as parallel tool_use blocks rather than sending the same question both broadcast and individually. " +
+  "You MUST end every session with Conclude — never end a turn with only text *after* every Ask round has resolved. " +
+  "If you can answer the task yourself, still call Conclude with verdict='success' and the answer as the summary.";
 
 /** System prompt appended for facilitated agent runners. */
 export const FACILITATED_AGENT_SYSTEM_PROMPT =
   "You participate in a coordinated session. " +
-  "Answer replies to an ask addressed to you. " +
-  "Ask sends a question to another participant. " +
-  "Announce broadcasts a message. " +
+  "Each question you receive carries an [ask#N] header — quote that N back as the askId field on Answer so the reply pairs with the right question. " +
+  "Answer replies to an ask addressed to you. askId is optional: omit it and the handler auto-picks if exactly one ask is owed to you, otherwise it routes your message as an Announce. " +
+  "Ask sends a question to another participant and returns immediately with {askIds:[N]}; the reply arrives on a later turn as `[answer#N] <participant>: <text>` in your inbox. " +
+  "Announce broadcasts a message to every other participant — use this for unsolicited remarks or to reply to an Announce. " +
   "RollCall lists participants.";
 
-/** Orchestrate N agent sessions coordinated by a single facilitator LLM session. */
-export class Facilitator {
+/**
+ * Facilitate-mode wrapper around `OrchestrationLoop`. The lead is named
+ * `"facilitator"`. `facilitatorRunner` getter is a readability shim for
+ * tests that read the runner directly.
+ */
+export class Facilitator extends OrchestrationLoop {
   /**
    * @param {object} deps
    * @param {import("./agent-runner.js").AgentRunner} deps.facilitatorRunner
    * @param {Array<{name: string, role: string, runner: import("./agent-runner.js").AgentRunner}>} deps.agents
    * @param {import("./message-bus.js").MessageBus} deps.messageBus
    * @param {import("stream").Writable} deps.output
-   * @param {number} [deps.maxTurns]
-   * @param {object} [deps.ctx]
-   * @param {object} [deps.eventQueue]
-   * @param {string} [deps.taskAmend] - Opaque addendum appended to the task before delivery.
+   * @param {object} deps.ctx
+   * @param {object} deps.redactor
+   * @param {string} [deps.taskAmend]
    */
-  constructor({
-    facilitatorRunner,
-    agents,
-    messageBus,
-    output,
-    maxTurns,
-    ctx,
-    eventQueue,
-    taskAmend,
-    redactor,
-  }) {
-    if (!redactor) throw new Error("redactor is required");
-    this.redactor = redactor;
-    this.facilitatorRunner = facilitatorRunner;
-    this.agents = agents;
-    this.messageBus = messageBus;
-    this.output = output;
-    this.maxTurns = maxTurns ?? 20;
-    this.ctx = ctx ?? createOrchestrationContext();
-    this.counter = new SequenceCounter();
-    this.eventQueue = eventQueue ?? createAsyncQueue();
-    this.facilitatorTurns = 0;
-    this.taskAmend = taskAmend ?? null;
-
-    let resolve;
-    const promise = new Promise((r) => {
-      resolve = r;
-    });
-    this.concludePromise = promise;
-    this.concludeResolve = resolve;
-  }
-
-  /**
-   * Run the full facilitated session.
-   * @param {string} task
-   * @returns {Promise<{success: boolean, turns: number}>}
-   */
-  async run(task) {
-    this.emitOrchestratorEvent({ type: "session_start" });
-
-    const initialTask = this.taskAmend ? `${task}\n\n${this.taskAmend}` : task;
-
-    // Launch agent loops first — they wait for messages via messageBus.
-    // This lets agents process Ask/Announce messages that arrive during
-    // the facilitator's initial run, rather than after it completes.
-    const agentPromises = this.agents.map((a) => this.#runAgent(a));
-
-    // Turn 0: facilitator receives the task
-    this.facilitatorTurns++;
-    await this.facilitatorRunner.run(initialTask);
-
-    // Handle redirect after turn 0
-    await this.#processRedirect();
-
-    if (this.ctx.concluded) {
-      // Facilitator concluded during its initial run. Let agents finish any
-      // in-progress work before returning — they may have received Ask/Answer
-      // messages and started processing concurrently.
-      this.concludeResolve();
-      await Promise.allSettled(agentPromises);
-      const success = this.ctx.verdict === "success";
-      this.emitSummary({
-        success,
-        verdict: this.ctx.verdict,
-        turns: this.facilitatorTurns,
-        summary: this.ctx.summary,
-      });
-      return { success, turns: this.facilitatorTurns };
-    }
-
-    // Abort agents promptly when Conclude is called during the event loop
-    this.concludePromise.then(() => {
-      for (const agent of this.agents) {
-        agent.runner.currentAbortController?.abort();
-      }
-    });
-
-    // Concurrent phase: facilitator event loop + already-running agent loops
-    const facilitatorPromise = this.#facilitatorLoop();
-
-    try {
-      await Promise.all([...agentPromises, facilitatorPromise]);
-    } catch (err) {
-      for (const agent of this.agents) {
-        agent.runner.currentAbortController?.abort();
-      }
-      this.facilitatorRunner.currentAbortController?.abort();
-      throw err;
-    }
-
-    const success = this.ctx.concluded && this.ctx.verdict === "success";
-    const result = {
-      success,
-      turns: this.facilitatorTurns,
-    };
-    this.emitSummary({
-      success,
-      verdict: this.ctx.verdict,
-      turns: result.turns,
-      summary: this.ctx.summary,
-    });
-    return result;
-  }
-
-  #checkAsk(name) {
-    return checkPendingAsk({
-      ctx: this.ctx,
-      messageBus: this.messageBus,
-      addresseeName: name,
+  constructor(deps) {
+    super({
+      ...deps,
+      leadRunner: deps.facilitatorRunner,
+      leadName: "facilitator",
       mode: "facilitated",
-      emitViolation: (e) => this.emitOrchestratorEvent(e),
     });
   }
 
-  async #enforcePendingAsk(agent) {
-    if (this.#checkAsk(agent.name) !== "recheck") return;
-    if (this.ctx.concluded) return;
-    const reminders = this.messageBus.drain(agent.name);
-    if (reminders.length === 0) return;
-    await agent.runner.resume(formatMessages(reminders));
-    if (this.ctx.concluded) return;
-    this.#checkAsk(agent.name);
-  }
-
-  /**
-   * Agent outer loop — waits for messages, runs/resumes the agent.
-   * @param {{name: string, role: string, runner: import("./agent-runner.js").AgentRunner}} agent
-   */
-  async #runAgent(agent) {
-    // Wait for first message (lazy start)
-    await Promise.race([
-      this.messageBus.waitForMessages(agent.name),
-      this.concludePromise,
-    ]);
-    if (this.ctx.concluded) return;
-
-    let messages = this.messageBus.drain(agent.name);
-    if (messages.length === 0) return;
-
-    this.emitOrchestratorEvent({ type: "agent_start", agent: agent.name });
-    await agent.runner.run(formatMessages(messages));
-    if (await this.#settleAgentTurn(agent)) return;
-
-    // Loop: check for new messages, resume if any
-    while (!this.ctx.concluded) {
-      messages = await this.#awaitAgentMessages(agent.name);
-      if (messages.length === 0) break;
-      await agent.runner.resume(formatMessages(messages));
-      if (await this.#settleAgentTurn(agent)) break;
-    }
-  }
-
-  /**
-   * Enforce pending-ask and emit turn_complete. Returns true when the
-   * session has concluded and the caller should stop.
-   */
-  async #settleAgentTurn(agent) {
-    if (this.ctx.concluded) return true;
-    await this.#enforcePendingAsk(agent);
-    if (this.ctx.concluded) return true;
-    this.eventQueue.enqueue({
-      type: "lifecycle",
-      agent: agent.name,
-      status: "turn_complete",
-    });
-    return false;
-  }
-
-  /**
-   * Wait for messages addressed to `name`, returning an empty array when
-   * the session concludes first.
-   */
-  async #awaitAgentMessages(name) {
-    const messages = this.messageBus.drain(name);
-    if (messages.length > 0) return messages;
-    await Promise.race([
-      this.messageBus.waitForMessages(name),
-      this.concludePromise,
-    ]);
-    if (this.ctx.concluded) return [];
-    return this.messageBus.drain(name);
-  }
-
-  /**
-   * Facilitator event loop — only runs when input arrives.
-   */
-  async #facilitatorLoop() {
-    while (!this.ctx.concluded) {
-      const event = await this.eventQueue.dequeue();
-      if (this.ctx.concluded || event === null) break;
-      await this.#handleEvent(event);
-    }
-  }
-
-  async #handleEvent(event) {
-    switch (event.type) {
-      case "messages":
-      case "lifecycle": {
-        const msgs = this.messageBus.drain("facilitator");
-        if (msgs.length === 0) break;
-        this.facilitatorTurns++;
-        await this.facilitatorRunner.resume(formatMessages(msgs));
-        await this.#processRedirect();
-        if (!this.ctx.concluded) await this.#enforceFacilitatorPendingAsk();
-        break;
-      }
-    }
-
-    if (this.ctx.concluded) {
-      this.concludeResolve();
-      this.eventQueue.close();
-    }
-  }
-
-  async #enforceFacilitatorPendingAsk() {
-    if (this.#checkAsk("facilitator") !== "recheck") return;
-    if (this.ctx.concluded) return;
-    const reminders = this.messageBus.drain("facilitator");
-    if (reminders.length === 0) return;
-    this.facilitatorTurns++;
-    await this.facilitatorRunner.resume(formatMessages(reminders));
-    await this.#processRedirect();
-    if (this.ctx.concluded) return;
-    this.#checkAsk("facilitator");
-  }
-
-  /**
-   * Process a pending redirect after a facilitator turn.
-   */
-  async #processRedirect() {
-    if (!this.ctx.redirect) return;
-    const redirect = this.ctx.redirect;
-    this.ctx.redirect = null;
-
-    this.emitOrchestratorEvent({
-      type: "redirect",
-      to: redirect.to,
-    });
-
-    if (redirect.to === "all") {
-      // Abort all agents and deliver redirect via broadcast
-      for (const agent of this.agents) {
-        agent.runner.currentAbortController?.abort();
-      }
-      this.messageBus.announce("facilitator", redirect.message);
-    } else if (redirect.to) {
-      // Abort specific agent and deliver via direct message
-      const target = this.agents.find((a) => a.name === redirect.to);
-      if (target) {
-        target.runner.currentAbortController?.abort();
-      }
-      this.messageBus.direct("facilitator", redirect.to, redirect.message);
-    }
-  }
-
-  /** Return the last assistant text block from a runner's buffer, or the fallback if none exists. */
-  extractLastText(runner, fallback) {
-    const lines = runner.buffer;
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const event = JSON.parse(lines[i]);
-      if (event.type !== "assistant") continue;
-      const content = event.message?.content ?? event.content;
-      if (!Array.isArray(content)) continue;
-      for (let j = content.length - 1; j >= 0; j--) {
-        if (content[j].type === "text" && content[j].text) {
-          return content[j].text;
-        }
-      }
-    }
-    return fallback;
-  }
-
-  /**
-   * Emit a single NDJSON line tagged with source and seq.
-   * @param {string} source - Participant name
-   * @param {string} line - Raw NDJSON line
-   */
-  emitLine(source, line) {
-    const event = JSON.parse(line);
-    this.output.write(
-      JSON.stringify(
-        this.redactor.redactValue({
-          source,
-          seq: this.counter.next(),
-          event,
-        }),
-      ) + "\n",
-    );
-  }
-
-  /**
-   * @param {{type: string}} event
-   */
-  emitOrchestratorEvent(event) {
-    this.output.write(
-      JSON.stringify(
-        this.redactor.redactValue({
-          source: "orchestrator",
-          seq: this.counter.next(),
-          event,
-        }),
-      ) + "\n",
-    );
-  }
-
-  /**
-   * @param {{success: boolean, verdict?: string|null, turns: number, summary?: string}} result
-   */
-  emitSummary(result) {
-    this.output.write(
-      JSON.stringify(
-        this.redactor.redactValue({
-          source: "orchestrator",
-          seq: this.counter.next(),
-          event: {
-            type: "summary",
-            success: result.success,
-            ...(result.verdict && { verdict: result.verdict }),
-            turns: result.turns,
-            ...(result.summary && { summary: result.summary }),
-          },
-        }),
-      ) + "\n",
-    );
+  /** Readability shim — exposes the lead runner under its mode-specific name. */
+  get facilitatorRunner() {
+    return this.leadRunner;
   }
 }
 
@@ -390,15 +83,15 @@ const devNull = new Writable({
  * @param {Array<{name: string, role: string, cwd?: string, maxTurns?: number, allowedTools?: string[], agentProfile?: string, systemPromptAmend?: string}>} deps.agentConfigs
  * @param {function} deps.query
  * @param {import("stream").Writable} deps.output
- * @param {string} [deps.model] - Default model for all participants.
- * @param {string} [deps.agentModel] - Agent model override (falls back to `model`).
- * @param {string} [deps.facilitatorModel] - Facilitator model override (falls back to `model`).
- * @param {number} [deps.maxTurns] - Facilitator's own per-invocation turn budget (default 20). Each participating agent's budget is taken from `config.maxTurns` on its entry in `agentConfigs` (default 50 when unset). The CLI command (`commands/facilitate.js`) threads `--max-turns` into both this parameter and every agent config so a single CLI value bounds all participants uniformly.
- * @param {string[]} [deps.facilitatorAllowedTools] - Tools the facilitator may use; defaults to a read/write file-edit set.
- * @param {string[]} [deps.facilitatorDisallowedTools] - Additional tools to block on the facilitator; merged with the sub-agent spawn defaults (Agent/Task/TaskOutput/TaskStop).
- * @param {string} [deps.facilitatorProfile] - Facilitator profile name; resolved into the main-thread system prompt via `composeProfilePrompt`.
- * @param {string} [deps.profilesDir] - Directory containing `<name>.md` profile files. Defaults to `<facilitatorCwd>/.claude/agents`. Resolved once from the facilitator's cwd so profiles travel with the project, not with per-agent sandboxes.
- * @param {string} [deps.taskAmend] - Opaque addendum appended to the task before delivery.
+ * @param {string} [deps.model]
+ * @param {string} [deps.agentModel]
+ * @param {string} [deps.facilitatorModel]
+ * @param {number} [deps.maxTurns] - Per-SDK-call turn budget for the facilitator runner (default 80). Each agent's budget is taken from `config.maxTurns` (default 50). The lead is resumed once per inbox-drain round, so this caps the size of one such round, not the whole session — `OrchestrationLoop.maxLeadTurns` bounds session length.
+ * @param {string[]} [deps.facilitatorAllowedTools]
+ * @param {string[]} [deps.facilitatorDisallowedTools]
+ * @param {string} [deps.facilitatorProfile]
+ * @param {string} [deps.profilesDir]
+ * @param {string} [deps.taskAmend]
  * @returns {Facilitator}
  */
 export function createFacilitator({
@@ -441,8 +134,6 @@ export function createFacilitator({
 
   let facilitator;
 
-  const eventQueue = createAsyncQueue();
-
   const facilitatorServer = createFacilitatorToolServer(ctx);
 
   const agents = agentConfigs.map((config) => {
@@ -484,7 +175,7 @@ export function createFacilitator({
     query,
     output: devNull,
     model: facilitatorModel ?? model,
-    maxTurns: maxTurns ?? 20,
+    maxTurns: maxTurns ?? 80,
     allowedTools: facilitatorAllowedTools ?? [
       "Bash",
       "Read",
@@ -509,9 +200,7 @@ export function createFacilitator({
     agents,
     messageBus,
     output,
-    maxTurns,
     ctx,
-    eventQueue,
     taskAmend,
     redactor,
   });

package/src/index.js

@@ -26,12 +26,24 @@ export {
   createJudgeToolServer,
 } from "./orchestration-toolkit.js";
 export { MessageBus, createMessageBus } from "./message-bus.js";
+export { OrchestrationLoop } from "./orchestration-loop.js";
 export {
   Facilitator,
   createFacilitator,
   FACILITATOR_SYSTEM_PROMPT,
   FACILITATED_AGENT_SYSTEM_PROMPT,
 } from "./facilitator.js";
+export {
+  Discusser,
+  createDiscusser,
+  DISCUSS_SYSTEM_PROMPT,
+  augmentContextForDiscuss,
+} from "./discusser.js";
+export {
+  createDiscussLeadToolServer,
+  createDiscussAgentToolServer,
+  DISCUSS_AGENT_SYSTEM_PROMPT,
+} from "./discuss-tools.js";
 export { Judge, createJudge, JUDGE_SYSTEM_PROMPT } from "./judge.js";
 export {
   Redactor,

package/src/judge.js

@@ -2,7 +2,7 @@
  * Judge — one agent session that inspects a completed agent's work and emits
  * a verdict via the orchestration `Conclude` tool. Parallel concept to
  * `Supervisor` and `Facilitator`, but post-hoc and solo: no peer agents,
- * no message bus, no relay loop. The judge reads the task, optionally
+ * no message bus, no orchestration loop. The judge reads the task, optionally
  * inspects the working directory and trace via read-only tools, and calls
  * Conclude exactly once.
  *

package/src/message-bus.js

@@ -1,22 +1,26 @@
 /**
- * MessageBus — in-memory per-participant message queues for facilitated and
- * supervised modes. The message vocabulary mirrors the orchestration toolkit:
+ * MessageBus — in-memory per-participant message queues.
  *
- * - ask(from, to, text, askId)       — direct question; registers nothing
- *   itself (the handler's caller owns pending-ask state). `to === "@broadcast"`
- *   sends an identical entry to every participant except the sender.
- * - answer(from, to, text, askId)    — direct reply to the asker.
- * - announce(from, text)             — broadcast, no reply expected.
- * - synthetic(to, text)              — orchestrator-only reminder injection.
+ * Four message kinds, each pushed onto the addressee's queue:
+ *
+ * - `ask(from, to, text, askId)` — direct question; the toolkit owns the
+ *   pending-ask state separately. Fan-out (broadcast Ask) happens at the
+ *   handler level by calling `ask()` once per addressee.
+ * - `answer(from, to, text, askId)` — direct reply to the original asker.
+ *   The orchestrator may inject synthetic answers (`from === "@orchestrator"`)
+ *   when an Ask times out.
+ * - `announce(from, text)` — broadcast, no reply expected; lands on every
+ *   participant's queue except the sender's.
+ * - `synthetic(to, text)` — orchestrator-only reminder injection.
  *
  * Follows OO+DI: constructor injection, factory function, tests bypass factory.
  */
 
-/** In-memory per-participant message queues for facilitated and supervised orchestration modes. */
+/** In-memory per-participant message queues. */
 export class MessageBus {
   /**
    * @param {object} deps
-   * @param {string[]} deps.participants - Participant names
+   * @param {string[]} deps.participants - Canonical participant names.
    */
   constructor({ participants }) {
     this.queues = new Map();
@@ -27,55 +31,30 @@ export class MessageBus {
     }
   }
 
-  /**
-   * Send a question to a participant (direct), or broadcast when
-   * `to === "@broadcast"`.
-   * @param {string} from
-   * @param {string} to - Recipient name or "@broadcast"
-   * @param {string} text
-   * @param {number} askId
-   */
+  /** Send a question to one participant. */
   ask(from, to, text, askId) {
     this.#assertParticipant(from);
-    if (to === "@broadcast") {
-      for (const [name, queue] of this.queues) {
-        if (name === from) continue;
-        queue.push({ from, text, kind: "ask", askId, direct: false });
-        this.#resolveWaiter(name);
-      }
-      return;
-    }
     this.#assertParticipant(to);
-    this.queues.get(to).push({ from, text, kind: "ask", askId, direct: true });
+    this.queues.get(to).push({ from, text, kind: "ask", askId });
     this.#resolveWaiter(to);
   }
 
   /**
-   * Reply to a pending ask.
-   * @param {string} from - Answerer (or "@orchestrator" for a synthetic answer)
-   * @param {string} to - Original asker
-   * @param {string} text
-   * @param {number} askId
+   * Reply to a pending ask. `from === "@orchestrator"` is allowed for
+   * synthetic null answers — the orchestrator is not a real participant
+   * but it routes through the bus.
    */
   answer(from, to, text, askId) {
     this.#assertParticipant(to);
-    // Synthetic answers from the orchestrator bypass the participant check
-    // on `from` — the orchestrator is not a message-bus participant.
     if (from !== "@orchestrator") this.#assertParticipant(from);
-    this.queues
-      .get(to)
-      .push({ from, text, kind: "answer", askId, direct: true });
+    this.queues.get(to).push({ from, text, kind: "answer", askId });
     this.#resolveWaiter(to);
   }
 
-  /**
-   * Broadcast a message to every participant except the sender.
-   * @param {string} from
-   * @param {string} text
-   */
+  /** Broadcast a message to every participant except the sender. */
   announce(from, text) {
     this.#assertParticipant(from);
-    const msg = { from, text, kind: "announce", direct: false };
+    const msg = { from, text, kind: "announce" };
     for (const [name, queue] of this.queues) {
       if (name === from) continue;
       queue.push(msg);
@@ -83,53 +62,24 @@ export class MessageBus {
     }
   }
 
-  /**
-   * Send a direct message with no reply expected. Used by the Redirect
-   * runtime plumbing (facilitator / supervisor) to deliver replacement
-   * instructions to a single participant without engaging the ask/answer
-   * contract.
-   * @param {string} from
-   * @param {string} to
-   * @param {string} text
-   */
-  direct(from, to, text) {
-    this.#assertParticipant(from);
-    this.#assertParticipant(to);
-    this.queues.get(to).push({ from, text, kind: "direct", direct: true });
-    this.#resolveWaiter(to);
-  }
-
-  /**
-   * Inject an orchestrator-originated reminder onto a single participant's
-   * queue. Used by the turn-complete guard.
-   * @param {string} to
-   * @param {string} text
-   */
+  /** Inject an orchestrator-originated reminder onto one participant's queue. */
   synthetic(to, text) {
     this.#assertParticipant(to);
     this.queues
       .get(to)
-      .push({ from: "@orchestrator", text, kind: "synthetic", direct: true });
+      .push({ from: "@orchestrator", text, kind: "synthetic" });
     this.#resolveWaiter(to);
   }
 
-  /**
-   * Return and clear pending messages for a participant.
-   * @param {string} participant - Participant name
-   * @returns {{from: string, text: string, kind: string, direct: boolean, askId?: number}[]}
-   */
+  /** Return and clear pending messages for a participant. */
   drain(participant) {
     this.#assertParticipant(participant);
-    const queue = this.queues.get(participant);
-    const messages = queue.splice(0);
-    return messages;
+    return this.queues.get(participant).splice(0);
   }
 
   /**
    * Return a Promise that resolves when at least one message is pending.
    * Resolves immediately if messages are already queued.
-   * @param {string} participant - Participant name
-   * @returns {Promise<void>}
    */
   waitForMessages(participant) {
     this.#assertParticipant(participant);
@@ -156,11 +106,7 @@ export class MessageBus {
   }
 }
 
-/**
- * Factory function.
- * @param {object} deps - Same as MessageBus constructor
- * @returns {MessageBus}
- */
+/** Factory function. */
 export function createMessageBus(deps) {
   return new MessageBus(deps);
 }