@forwardimpact/libeval 0.1.44 → 0.1.46

package/src/agent-runner.js

@@ -1,7 +1,7 @@
 /**
- * AgentRunner — runs a single Claude Agent SDK session and emits raw NDJSON
- * events to an output stream. Building block for both `fit-eval run` and
- * `fit-eval supervise`.
+ * AgentRunner — runs a single Claude Agent SDK session and emits raw
+ * NDJSON events to an output stream. Building block for `fit-eval run`,
+ * `fit-eval supervise`, `fit-eval facilitate`, and `fit-eval discuss`.
  *
  * Follows OO+DI: constructor injection, factory function, tests bypass factory.
  */
@@ -13,25 +13,6 @@ const DEFAULT_ALLOWED_TOOLS = ["Bash", "Read", "Glob", "Grep", "Write", "Edit"];
 // overridable — so a future caller can't accidentally reduce permissions.
 const PERMISSION_MODE = "bypassPermissions";
 
-function applyDefaults(deps) {
-  return {
-    cwd: deps.cwd,
-    query: deps.query,
-    output: deps.output,
-    model: deps.model ?? "claude-opus-4-7[1m]",
-    maxTurns: deps.maxTurns ?? 50,
-    allowedTools: deps.allowedTools ?? DEFAULT_ALLOWED_TOOLS,
-    onLine: deps.onLine ?? null,
-    onBatch: deps.onBatch ?? null,
-    batchSize: deps.batchSize ?? 3,
-    settingSources: deps.settingSources ?? [],
-    systemPrompt: deps.systemPrompt ?? null,
-    disallowedTools: deps.disallowedTools ?? [],
-    mcpServers: deps.mcpServers ?? null,
-    taskAmend: deps.taskAmend ?? null,
-  };
-}
-
 /** Run a single Claude Agent SDK session and emit raw NDJSON events to an output stream. */
 export class AgentRunner {
   /**
@@ -43,29 +24,38 @@ export class AgentRunner {
    * @param {number} [deps.maxTurns] - Maximum agentic turns; 0 means unlimited
    * @param {string[]} [deps.allowedTools] - Tools the agent may use
    * @param {function} [deps.onLine] - Callback invoked with each NDJSON line as it's produced
-   * @param {function} [deps.onBatch] - Async callback invoked with a batch of NDJSON lines at flush boundaries: every `batchSize` assistant text blocks, the terminal `result` message, and — on iterator crash/abort — once more in a final flush carrying any lines that never reached a boundary. Receives `(lines, { abort })` where calling `abort()` stops the in-flight SDK session via the AbortController. Optional; assignable at runtime so the Supervisor can swap it per turn.
-   * @param {number} [deps.batchSize] - Assistant text-block messages to accumulate before firing onBatch. Tool-only assistant messages ride along without counting. Default 3: the supervisor reviews the agent every three text turns instead of every turn. The terminal `result` always flushes regardless of count.
    * @param {string[]} [deps.settingSources] - SDK setting sources (e.g. ['project'] to load CLAUDE.md)
    * @param {string|object} [deps.systemPrompt] - SDK system prompt (string replaces default; {type:'preset', preset:'claude_code', append} appends)
    * @param {string[]} [deps.disallowedTools] - Tools to explicitly remove from the model's context
    * @param {Record<string, object>} [deps.mcpServers] - MCP server configs to pass to the SDK query
+   * @param {object} deps.redactor
    */
   constructor(deps) {
     if (!deps.cwd) throw new Error("cwd is required");
     if (!deps.query) throw new Error("query is required");
     if (!deps.output) throw new Error("output is required");
     if (!deps.redactor) throw new Error("redactor is required");
-    Object.assign(this, applyDefaults(deps));
+    this.cwd = deps.cwd;
+    this.query = deps.query;
+    this.output = deps.output;
     this.redactor = deps.redactor;
+    this.model = deps.model ?? "claude-opus-4-7[1m]";
+    this.maxTurns = deps.maxTurns ?? 50;
+    this.allowedTools = deps.allowedTools ?? DEFAULT_ALLOWED_TOOLS;
+    this.onLine = deps.onLine ?? null;
+    this.settingSources = deps.settingSources ?? [];
+    this.systemPrompt = deps.systemPrompt ?? null;
+    this.disallowedTools = deps.disallowedTools ?? [];
+    this.mcpServers = deps.mcpServers ?? null;
+    this.taskAmend = deps.taskAmend ?? null;
     this.sessionId = null;
-    this.buffer = [];
     /** @type {AbortController|null} */
     this.currentAbortController = null;
   }
 
   /**
    * Run a new agent session with the given task.
-   * @param {string} task - The task prompt
+   * @param {string} task
    * @returns {Promise<{success: boolean, text: string, sessionId: string|null, error: Error|null, aborted: boolean}>}
    */
   async run(task) {
@@ -87,7 +77,7 @@ export class AgentRunner {
 
   /**
    * Resume an existing session with a follow-up prompt.
-   * @param {string} prompt - The follow-up prompt
+   * @param {string} prompt
    * @returns {Promise<{success: boolean, text: string, sessionId: string|null, error: Error|null, aborted: boolean}>}
    */
   async resume(prompt) {
@@ -108,17 +98,16 @@ export class AgentRunner {
   }
 
   /**
-   * Build the options passed to every SDK query() call. Shared by run() and
-   * resume() so the agent's configuration — cwd, tools, prompt, setting
-   * sources, turn budget — is identical across the session's lifetime. Only
-   * resume() layers `resume: this.sessionId` on top.
+   * Build the options passed to every SDK query() call. Shared by run()
+   * and resume() so the agent's configuration — cwd, tools, prompt,
+   * setting sources, turn budget — is identical across the session's
+   * lifetime. Only resume() layers `resume: this.sessionId` on top.
    *
-   * SDK options are call-attached, not session-attached: the resumed call
-   * loads the prior conversation but otherwise uses whatever options this
-   * call passes. Omitting tool/prompt/setting options on resume causes the
-   * agent to silently lose its restrictions and persona between turns.
-   * @param {AbortController} abortController
-   * @returns {object}
+   * SDK options are call-attached, not session-attached: the resumed
+   * call loads the prior conversation but otherwise uses whatever
+   * options this call passes. Omitting tool/prompt/setting options on
+   * resume causes the agent to silently lose its restrictions and
+   * persona between turns.
    */
   #callOptions(abortController) {
     return {
@@ -139,59 +128,28 @@ export class AgentRunner {
   }
 
   /**
-   * Shared consumer for both `run()` and `resume()`. Iterates the SDK query
-   * iterator, mirroring every line to the output stream / buffer / onLine
-   * callback, and — when `onBatch` is set — flushes accumulated lines to it
-   * at coarse boundaries: every `batchSize` assistant text-block messages,
-   * and the terminal `result` message. Tool-only assistant messages still
-   * accumulate in the pending batch and ride along in the next flush, so
-   * the supervisor always sees the tool calls that led up to each text
-   * block. Raising `batchSize` above 1 is the knob that makes the mid-turn
-   * supervisor review less chatty — with the default of 3, the supervisor
-   * sees the agent in chunks of three text turns instead of every turn.
-   *
-   * Corollary: a turn that is *entirely* tool_use with no text blocks and
-   * then hits `result` produces exactly one flush at `result` regardless
-   * of how many tools ran. That is deliberate — the supervisor only needs
-   * to weigh in when the agent surfaces something text-like to react to.
-   *
-   * INVARIANT: the `await this.onBatch(...)` call below is the ONLY
-   * suspension point in this loop. While it is pending, no further lines
-   * are pulled from the SDK generator. The Supervisor relies on this — its
-   * onBatch callback flips `currentSource` to "supervisor" for the duration
-   * of its mid-turn LLM call, and the invariant guarantees no agent line
-   * can arrive concurrently and be mis-tagged.
-   *
-   * If the supervisor calls `abort()` from inside the callback, the next
-   * iteration of the for-await loop will throw. We catch the throw, check
-   * `currentAbortController.signal.aborted` (avoiding fragility around
-   * AbortError vs DOMException shapes), and report `aborted: true` so the
-   * caller can distinguish "supervisor asked us to stop" from a real error.
+   * Iterate the SDK query iterator, mirroring every message to the
+   * output stream and the `onLine` callback. Captures `sessionId` from
+   * the SDK's `system/init` message and tracks Skill invocations into
+   * `LIBEVAL_SKILL` for downstream metrics.
    *
-   * If the iterator throws before a flush boundary, any lines still in the
-   * pending batch would otherwise vanish without the supervisor seeing
-   * them. The `finally` block emits a terminal batch so the supervisor can
-   * observe the partial state (e.g. note a crash or react to an external
-   * abort). A throw from that final flush becomes the returned `error`
-   * only if no earlier error was captured — the original failure wins.
-   * @param {AsyncIterable<object>} iterator
-   * @returns {Promise<{success: boolean, text: string, sessionId: string|null, error: Error|null, aborted: boolean}>}
+   * If the iterator throws and we triggered the abort ourselves
+   * (`currentAbortController.signal.aborted`), we report `aborted:
+   * true`; otherwise the error propagates as `error`.
    */
   async #consumeQuery(iterator) {
     let text = "";
     let stopReason = null;
     let error = null;
     let aborted = false;
-    const state = { pendingBatch: [], assistantTextCount: 0 };
 
     try {
       for await (const message of iterator) {
-        this.#recordLine(message, state);
+        this.#recordLine(message);
         if (message.type === "result") {
           text = message.result ?? "";
           stopReason = message.subtype;
         }
-        await this.#maybeFlushBatch(message, state);
       }
     } catch (err) {
       if (this.currentAbortController?.signal.aborted) {
@@ -201,118 +159,28 @@ export class AgentRunner {
       }
     }
 
-    const flushErr = await this.#terminalFlush(state, { error, aborted });
-    if (flushErr && !error) error = flushErr;
-
-    const success = stopReason === "success";
-    return { success, text, sessionId: this.sessionId, error, aborted };
+    return {
+      success: stopReason === "success",
+      text,
+      sessionId: this.sessionId,
+      error,
+      aborted,
+    };
   }
 
-  /**
-   * Mirror a single SDK message to the output stream, buffer, onLine
-   * callback, and (when set) the pending-batch state. Also handles
-   * session id capture and text-block counting so `#consumeQuery` can
-   * stay within the complexity budget.
-   * @param {object} message
-   * @param {{pendingBatch: string[], assistantTextCount: number}} state
-   */
-  #recordLine(message, state) {
+  #recordLine(message) {
     const redacted = this.redactor.redactValue(message);
     const line = JSON.stringify(redacted);
     this.output.write(line + "\n");
-    this.buffer.push(line);
     if (this.onLine) this.onLine(line);
-    if (this.onBatch) state.pendingBatch.push(line);
 
-    // Session-id / text-block tracking reads the ORIGINAL message —
-    // these fields are not secret carriers, and the trackers rely on
-    // shape, not string contents.
     if (message.type === "system" && message.subtype === "init") {
       this.sessionId = message.session_id;
     }
-    if (message.type === "assistant") {
-      if (hasTextBlock(message)) state.assistantTextCount++;
-      trackSkillInvocation(message);
-    }
-  }
-
-  /**
-   * Terminal flush — only fires on the abnormal-end paths (iterator
-   * threw or was aborted mid-stream). Delivers any pending lines so the
-   * supervisor sees the partial state instead of losing the tail of
-   * the run. A natural-end iterator that simply ran out of messages
-   * without a `result` marker is treated as an incomplete stub (the
-   * real SDK always terminates with `result`) and its pending batch is
-   * not re-flushed. Returns an error thrown by the flush callback, or
-   * `null` if the flush succeeded or did not fire.
-   * @param {{pendingBatch: string[], assistantTextCount: number}} state
-   * @param {{error: Error|null, aborted: boolean}} outcome
-   * @returns {Promise<Error|null>}
-   */
-  async #terminalFlush(state, { error, aborted }) {
-    const loopEndedAbnormally = Boolean(error || aborted);
-    if (!loopEndedAbnormally) return null;
-    if (!this.onBatch || state.pendingBatch.length === 0) return null;
-    try {
-      const batchLines = state.pendingBatch.splice(0);
-      await this.onBatch(batchLines, {
-        abort: () => this.currentAbortController?.abort(),
-      });
-      return null;
-    } catch (flushErr) {
-      return flushErr;
-    }
-  }
-
-  /**
-   * Flush the pending batch to `onBatch` if either the batchSize threshold
-   * has been reached or the current message is the terminal `result`.
-   * Extracted so that `#consumeQuery` stays within the project's complexity
-   * budget — the flush is one cohesive unit of logic in its own right.
-   * @param {object} message
-   * @param {{pendingBatch: string[], assistantTextCount: number}} state
-   */
-  async #maybeFlushBatch(message, state) {
-    if (!this.onBatch) return;
-    const shouldFlush =
-      message.type === "result" || state.assistantTextCount >= this.batchSize;
-    if (!shouldFlush) return;
-    state.assistantTextCount = 0;
-    const batchLines = state.pendingBatch.splice(0);
-    await this.onBatch(batchLines, {
-      abort: () => this.currentAbortController?.abort(),
-    });
-  }
-
-  /**
-   * Drain buffered output lines. Used by Supervisor to tag and re-emit lines.
-   * @returns {string[]}
-   */
-  drainOutput() {
-    const lines = [...this.buffer];
-    this.buffer = [];
-    return lines;
+    if (message.type === "assistant") trackSkillInvocation(message);
   }
 }
 
-/**
- * Whether an SDK assistant message contains at least one text block.
- * Only text-block messages count toward the `batchSize` threshold — tool-only
- * assistant messages accumulate silently into the pending batch and ride along
- * in the next flush, keeping supervisor LLM cost bounded. Exported so the mock
- * runner can mirror the real flush predicate without duplicating the logic.
- * @param {object} message
- * @returns {boolean}
- */
-export function hasTextBlock(message) {
-  const content = message.message?.content ?? message.content;
-  if (!Array.isArray(content)) return false;
-  for (const block of content) {
-    if (block.type === "text" && block.text) return true;
-  }
-  return false;
-}
-
 function trackSkillInvocation(message) {
   const content = message.message?.content ?? message.content;
   if (!Array.isArray(content)) return;
@@ -327,11 +195,7 @@ function trackSkillInvocation(message) {
   }
 }
 
-/**
- * Factory function — wires real dependencies.
- * @param {object} deps - Same as AgentRunner constructor
- * @returns {AgentRunner}
- */
+/** Factory function — wires real dependencies. */
 export function createAgentRunner(deps) {
   return new AgentRunner(deps);
 }

package/src/benchmark/runner.js

@@ -3,7 +3,7 @@
  *
  * Phases per (task, runIndex):
  *   1. WorkdirManager.start → seed CWD + run pre-flight probe
- *   2. Supervisor relay (agent + supervisor) → produce traces + submission
+ *   2. Supervisor session (agent + supervisor) → produce traces + submission
  *   3. Scorer.runScoring → exit-code-driven verdict via fd-3 NDJSON
  *   4. Judge.runJudge → Conclude-driven verdict mapped to pass/fail
  *   5. WorkdirManager.teardown → process-group cleanup
@@ -272,7 +272,7 @@ export class BenchmarkRunner {
   }
 
   /**
-   * Run the agent-under-test via a Supervisor relay. The supervisor writes
+   * Run the agent-under-test under a Supervisor. The supervisor writes
    * a combined tagged NDJSON trace; after the session we split it into
    * agent.ndjson and supervisor.ndjson and extract cost/turns/submission.
    */

package/src/commands/supervise.js

@@ -53,7 +53,9 @@ export function parseSuperviseOptions(values) {
 }
 
 /**
- * Supervise command — run two agents in a relay loop via the Claude Agent SDK.
+ * Supervise command — run one agent under a supervisor via the
+ * orchestration loop. The supervisor delegates work through Ask, sees
+ * each reply on its next turn, and ends with Conclude.
  *
  * Usage: fit-eval supervise [options]
  *

package/src/discuss-tools.js

@@ -1,32 +1,33 @@
 /**
- * DiscussTools — tool servers and prompts for the `discuss` orchestration
- * mode. The lead's set is sibling to (not derived from) the facilitator's:
- * `Conclude` is absent; instead `Adjourn` (terminal verdict) and `Recess`
- * (suspend with a ResumeTrigger) end a run, and `RequestForComment` queues
- * structured replies onto the trace for the bridge to deliver after the
- * workflow run completes.
+ * DiscussTools — discuss-mode tool servers. The lead's surface extends the
+ * base set with three discuss-only terminal tools:
  *
- * Discuss-mode prompts and tool wiring stay in this module; nothing here
- * imports from `facilitator.js`.
+ * - `RequestForComment` posts a fire-and-forget message to a human channel
+ *   via the bridge; the reply arrives on a later workflow run.
+ * - `Recess` suspends the session with a resumption trigger.
+ * - `Adjourn` ends the discussion with a verdict.
+ *
+ * `Conclude` is absent — discuss mode ends via Adjourn or Recess. The
+ * agent surface is identical to the facilitated agent's: Ask / Answer /
+ * Announce / RollCall, with Ask defaulting to the lead.
  */
 
-import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
 
 import {
-  createAskHandler,
-  createAnswerHandler,
-  createAnnounceHandler,
-  createRollCallHandler,
-  createRedirectHandler,
+  baseTools,
+  concludeSession,
+  orchestrationServer,
 } from "./orchestration-toolkit.js";
 
 /** System prompt appended for discuss-mode agent runners. */
 export const DISCUSS_AGENT_SYSTEM_PROMPT =
   "You participate in an asynchronous discussion. " +
-  "Answer replies to an ask addressed to you. " +
-  "Ask sends a question to the lead or 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 the lead or 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.";
 
 const RESUME_TRIGGER_SCHEMA = z
@@ -37,128 +38,51 @@ const RESUME_TRIGGER_SCHEMA = z
   })
   .strict();
 
-/**
- * Lead tools for the discusser. The discuss-mode surface is Ask / Answer /
- * Announce / Redirect / RollCall plus the discuss-only RequestForComment,
- * Recess, and Adjourn. `Conclude` is intentionally absent — discuss mode
- * ends via Adjourn or Recess, never Conclude. `RequestForComment` writes
- * a structured reply onto `ctx.replies[]`; the discusser flushes those
- * into the terminal summary event at end-of-run.
- *
- * @param {object} ctx - Orchestration context (must carry `replies` array)
- * @returns {object} MCP server config (type: "sdk")
- */
+/** Discuss-mode lead tool server. */
 export function createDiscussLeadToolServer(ctx) {
-  return createSdkMcpServer({
-    name: "orchestration",
-    tools: [
-      tool(
-        "RollCall",
-        "List all participants in the session.",
-        {},
-        createRollCallHandler(ctx),
-      ),
-      tool(
-        "Ask",
-        "Send a question to a participant. Omit 'to' to broadcast. The reply arrives via Answer.",
-        { question: z.string(), to: z.string().optional() },
-        createAskHandler(ctx, { from: "lead", defaultTo: undefined }),
-      ),
-      tool(
-        "Answer",
-        "Reply to an ask addressed to you.",
-        { message: z.string() },
-        createAnswerHandler(ctx, { from: "lead" }),
-      ),
-      tool(
-        "Announce",
-        "Broadcast a message with no reply expected.",
-        { message: z.string() },
-        createAnnounceHandler(ctx, { from: "lead" }),
-      ),
-      tool(
-        "Redirect",
-        "Interrupt a participant with replacement instructions.",
-        { message: z.string(), to: z.string().optional() },
-        createRedirectHandler(ctx),
-      ),
-      tool(
-        "RequestForComment",
-        "Post a fire-and-forget message to a channel via the bridge. Returns a correlation id; the reply arrives on a later workflow run.",
-        {
-          channel: z.string(),
-          body: z.string(),
-          addressees: z.array(z.string()).optional(),
-        },
-        createRequestForCommentHandler(ctx),
-      ),
-      tool(
-        "Recess",
-        "Suspend the run. The bridge re-dispatches the workflow when the trigger fires.",
-        { reason: z.string(), trigger: RESUME_TRIGGER_SCHEMA },
-        createRecessHandler(ctx),
-      ),
-      tool(
-        "Adjourn",
-        "End the discussion with a verdict and a summary.",
-        {
-          verdict: z.enum(["adjourned", "failed"]),
-          summary: z.string(),
-          outcome: z.string().optional(),
-        },
-        createAdjournHandler(ctx),
-      ),
-    ],
-  });
+  return orchestrationServer([
+    ...baseTools(ctx, { from: "lead", defaultTo: undefined, broadcast: true }),
+    tool(
+      "RequestForComment",
+      "Post a fire-and-forget message to a channel via the bridge. Returns a correlation id; the reply arrives on a later workflow run.",
+      {
+        channel: z.string(),
+        body: z.string(),
+        addressees: z.array(z.string()).optional(),
+      },
+      createRequestForCommentHandler(ctx),
+    ),
+    tool(
+      "Recess",
+      "Suspend the run. The bridge re-dispatches the workflow when the trigger fires.",
+      { reason: z.string(), trigger: RESUME_TRIGGER_SCHEMA },
+      createRecessHandler(ctx),
+    ),
+    tool(
+      "Adjourn",
+      "End the discussion with a verdict ('adjourned' / 'failed') and a summary.",
+      {
+        verdict: z.enum(["adjourned", "failed"]),
+        summary: z.string(),
+        outcome: z.string().optional(),
+      },
+      createAdjournHandler(ctx),
+    ),
+  ]);
 }
 
-/**
- * Discuss-mode agent tools: Ask / Answer / Announce / RollCall. Surface is
- * defined here (not borrowed from facilitate mode) so the two modes stay
- * structurally independent.
- *
- * @param {object} ctx - Orchestration context
- * @param {{from: string}} opts - Agent name (canonical)
- * @returns {object} MCP server config (type: "sdk")
- */
+/** Discuss-mode agent tool server. */
 export function createDiscussAgentToolServer(ctx, { from }) {
-  return createSdkMcpServer({
-    name: "orchestration",
-    tools: [
-      tool(
-        "Ask",
-        "Send a question to another participant. Omit 'to' to ask the lead.",
-        { question: z.string(), to: z.string().optional() },
-        createAskHandler(ctx, { from, defaultTo: "lead" }),
-      ),
-      tool(
-        "Answer",
-        "Reply to an ask addressed to you.",
-        { message: z.string() },
-        createAnswerHandler(ctx, { from }),
-      ),
-      tool(
-        "Announce",
-        "Broadcast a message with no reply expected.",
-        { message: z.string() },
-        createAnnounceHandler(ctx, { from }),
-      ),
-      tool(
-        "RollCall",
-        "List all participants in the session.",
-        {},
-        createRollCallHandler(ctx),
-      ),
-    ],
-  });
+  return orchestrationServer(
+    baseTools(ctx, { from, defaultTo: "lead", broadcast: true }),
+  );
 }
 
-/** Create a RequestForComment handler. Queues a reply into ctx.replies[]. */
+/** RequestForComment handler — queues structured replies on `ctx.replies[]`. */
 export function createRequestForCommentHandler(ctx) {
   return async ({ channel, body, addressees }) => {
     const correlationId = `rfc_${++ctx.rfcCounter}`;
-    const addresseeList =
-      Array.isArray(addressees) && addressees.length > 0 ? addressees : [null];
+    const addresseeList = addressees?.length ? addressees : [null];
     for (const addressee of addresseeList) {
       ctx.replies.push({
         ...(addressee && { addressee }),
@@ -178,26 +102,34 @@ export function createRequestForCommentHandler(ctx) {
   };
 }
 
-/** Create a Recess handler. Marks the session as recessed with a trigger. */
+/**
+ * Recess handler — ends the run with a structured pause + resumption
+ * trigger; cancels any open Asks so askers see a synthetic null answer.
+ * `concluded` flips true (same as Adjourn); the `recessed` verdict
+ * distinguishes them, and `recessTrigger` carries the resume shape for
+ * the bridge.
+ */
 export function createRecessHandler(ctx) {
   return async ({ reason, trigger }) => {
-    ctx.recessed = true;
     ctx.recessTrigger = trigger;
-    ctx.recessReason = reason;
-    ctx.concluded = true;
-    ctx.verdict = "recessed";
-    ctx.summary = reason;
+    concludeSession(ctx, {
+      verdict: "recessed",
+      summary: reason,
+      reason: "session recessed",
+    });
     return { content: [{ type: "text", text: "Recess queued." }] };
   };
 }
 
-/** Create an Adjourn handler. Marks the session as concluded with a verdict. */
+/** Adjourn handler — ends the discussion with a verdict. */
 export function createAdjournHandler(ctx) {
   return async ({ verdict, summary, outcome }) => {
-    ctx.concluded = true;
-    ctx.verdict = verdict;
-    ctx.summary = summary;
     if (outcome !== undefined) ctx.outcome = outcome;
+    concludeSession(ctx, {
+      verdict,
+      summary,
+      reason: "session adjourned",
+    });
     return { content: [{ type: "text", text: "Session adjourned." }] };
   };
 }