@forwardimpact/libharness 1.3.0 → 2.0.0

package/src/commands/assert.js

@@ -62,12 +62,74 @@ export function evaluateAssertion(values, args, fsSync) {
 
   const output = { test: testName, pass: result.pass };
   if (result.message) output.message = result.message;
+  applyGradingFlags(values, output);
   return output;
 }
 
+/**
+ * Attach the check-row grading role: `--gate` marks a gate check, `--weight`
+ * attaches a numeric weight (0 marks the row diagnostic). `--gate` with any
+ * `--weight` — 0 included — is invalid: a stray weight must never silently
+ * disarm a gate.
+ * @param {object} values
+ * @param {{test: string, pass: boolean, message?: string}} output - Mutated.
+ */
+function applyGradingFlags(values, output) {
+  const hasWeight = values.weight !== undefined;
+  if (values.gate && hasWeight) {
+    throw new Error("assert: --gate cannot be combined with --weight");
+  }
+  if (values.gate) output.gate = true;
+  if (hasWeight) {
+    const weight = parseWeight(values.weight);
+    if (weight === null) {
+      throw new Error(
+        `assert: invalid --weight '${values.weight}' (expected a finite number ≥ 0)`,
+      );
+    }
+    output.weight = weight;
+  }
+}
+
+/**
+ * Parse a `--weight` value; null when invalid. A blank string is invalid —
+ * `Number("")` is 0, which would silently demote the check to a diagnostic.
+ * @param {string} raw
+ * @returns {number | null}
+ */
+function parseWeight(raw) {
+  if (typeof raw === "string" && raw.trim() === "") return null;
+  const weight = Number(raw);
+  return Number.isFinite(weight) && weight >= 0 ? weight : null;
+}
+
+/**
+ * The grading role an emit-then-fail row keeps: a failing check must not
+ * lose its authored role — an errored gate that demoted to a scored row
+ * would let a broken scaffold earn partial credit instead of zeroing the
+ * score. Invalid or conflicting flags yield no role (the row fails as a
+ * unit-weight scored check).
+ * @param {object} values
+ * @returns {{gate?: true, weight?: number}}
+ */
+function errorRowRole(values) {
+  const hasWeight = values.weight !== undefined;
+  if (values.gate && !hasWeight) return { gate: true };
+  if (!values.gate && hasWeight) {
+    const weight = parseWeight(values.weight);
+    if (weight !== null) return { weight };
+  }
+  return {};
+}
+
 /**
  * Run an assertion, write JSON to stdout, and return a failure envelope when
  * the assertion does not pass.
+ *
+ * Emit-then-fail on every failure path: an invalid grading flag or an
+ * errored evaluation (e.g. `--grep` against a file the agent deleted) writes
+ * a failing row before the nonzero exit, so a typo or a vanished target
+ * shrinks the score, never the denominator.
  * @param {import("@forwardimpact/libcli").InvocationContext} ctx
  * @returns {Promise<{ok: true} | {ok: false, code: number, error: string}>}
  */
@@ -78,6 +140,16 @@ export async function runAssertCommand(ctx) {
   try {
     result = evaluateAssertion(ctx.options, args, runtime.fsSync);
   } catch (err) {
+    const reason = err.message.startsWith("assert: ")
+      ? err.message
+      : `assert: ${err.message}`;
+    const row = {
+      test: ctx.args["test-name"] ?? "(missing test name)",
+      pass: false,
+      ...errorRowRole(ctx.options),
+      message: reason,
+    };
+    runtime.proc.stdout.write(JSON.stringify(row) + "\n");
     return { ok: false, code: 1, error: err.message };
   }
   runtime.proc.stdout.write(JSON.stringify(result) + "\n");

package/src/commands/benchmark-definition.js

@@ -5,7 +5,7 @@
  */
 
 import { runBenchmarkRunCommand } from "./benchmark-run.js";
-import { runBenchmarkInvariantsCommand } from "./benchmark-invariants.js";
+import { runBenchmarkGradeCommand } from "./benchmark-grade.js";
 import { runBenchmarkReportCommand } from "./benchmark-report.js";
 import {
   BENCHMARK_AGENT_MODEL,
@@ -95,11 +95,11 @@ export const definition = {
       },
     },
     {
-      name: "invariants",
+      name: "grade",
       args: [],
-      handler: runBenchmarkInvariantsCommand,
+      handler: runBenchmarkGradeCommand,
       description:
-        "Check a single task's invariants against a post-run workdir without invoking an agent.",
+        "Grade a single task against a post-run workdir without invoking an agent: run the hidden test suite and the invariants script, then derive the verdict from the check rows (the exit mirrors it).",
       options: {
         family: {
           type: "string",
@@ -112,7 +112,7 @@ export const definition = {
         "run-dir": {
           type: "string",
           description:
-            "Post-run directory whose cwd/ subdir is the agent CWD; invariants run against that cwd — the path hooks receive as $AGENT_CWD",
+            "Post-run directory whose cwd/ subdir is the agent CWD; both producers run against that cwd — the path hooks receive as $AGENT_CWD",
         },
         output: {
           type: "string",
@@ -140,6 +140,11 @@ export const definition = {
           type: "string",
           description: "Output format (json|text, default: json)",
         },
+        detail: {
+          type: "string",
+          description:
+            "Text report verbosity (full|compact, default: full). compact omits per-task detail — useful for sharded run summaries.",
+        },
       },
     },
   ],
@@ -154,7 +159,7 @@ export const definition = {
     "fit-benchmark run --family=./families/coding --work-tracker=filesystem",
     "fit-benchmark run --family=./families/coding --skills-from=. --task=todo-api",
     `fit-benchmark run --family=./families/coding --runs=10 --agent-model=${BENCHMARK_AGENT_MODEL}`,
-    "fit-benchmark invariants --family=./families/coding --task=todo-api --run-dir=./benchmark-runs/runs/todo-api/0",
+    "fit-benchmark grade --family=./families/coding --task=todo-api --run-dir=./benchmark-runs/runs/todo-api/0",
     "fit-benchmark report --format=text",
     "fit-benchmark report --input=./runs/today --k=1,3,5 --format=text",
   ],

package/src/commands/benchmark-grade.js

@@ -0,0 +1,82 @@
+/**
+ * `fit-benchmark grade` — run both check-row producers (the hidden test
+ * suite and the invariants script) against a post-run workdir directory and
+ * grade the merged rows with the same derivation the benchmark runner uses.
+ * No agent and no judge run, so authors validate a task's grading material
+ * against fixtures without paying for agent sessions; the process exit
+ * mirrors the graded verdict.
+ */
+
+import { join, resolve } from "node:path";
+
+import { validateGradeRecord } from "../benchmark/result.js";
+import { runInvariants } from "../benchmark/invariants.js";
+import { runHiddenTests } from "../benchmark/hidden-tests.js";
+import { runProducersAndGrade } from "../benchmark/grade.js";
+import { loadTaskFamily } from "../benchmark/task-family.js";
+import { probeFreePort } from "../benchmark/workdir.js";
+
+/**
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: true} | {ok: false, code: number, error: string}>}
+ */
+export async function runBenchmarkGradeCommand(ctx) {
+  const values = ctx.options;
+  const runtime = ctx.deps.runtime;
+  const familyInput = values.family;
+  if (!familyInput)
+    return { ok: false, code: 1, error: "--family is required" };
+  const taskId = values.task;
+  if (!taskId) return { ok: false, code: 1, error: "--task is required" };
+  const runDirArg = values["run-dir"];
+  if (!runDirArg) return { ok: false, code: 1, error: "--run-dir is required" };
+
+  const family = await loadTaskFamily(familyInput, runtime);
+  const task = family.tasks().find((t) => t.id === taskId);
+  if (!task)
+    return { ok: false, code: 1, error: `task not found in family: ${taskId}` };
+
+  const runDir = resolve(runDirArg);
+  const cwd = join(runDir, "cwd");
+  const port = await probeFreePort();
+  const cellCtx = { cwd, port, runDir, familyDir: family.rootPath };
+
+  const { invariants, hiddenRows, engineError, healthy, grade } =
+    await runProducersAndGrade(task, cellCtx, runtime, {
+      runInvariants,
+      runHiddenTests,
+    });
+  // Same effective-score rule as the runner, minus the judge (none runs
+  // here): an unhealthy grader or a failing gate zeroes the score, so a
+  // crashed hook can never mint marks from the rows it emitted before dying.
+  // Unlike a runner record — where `grade.score` stays the raw fraction and
+  // the zeroing lands on the top-level `score` — this record has no second
+  // field, so `grade.score` carries the effective value here.
+  if (grade.score !== undefined && !(healthy && grade.gatesPass)) {
+    grade.score = 0;
+  }
+  const record = {
+    taskId: task.id,
+    grade,
+    invariants,
+    ...(task.tests && {
+      hiddenTests: {
+        details: hiddenRows,
+        ...(engineError && { error: engineError.message }),
+      },
+    }),
+    // Mirrors the script for diagnosis; the graded verdict drives the exit.
+    exitCode: invariants.exitCode,
+  };
+  validateGradeRecord(record);
+
+  const line = JSON.stringify(record) + "\n";
+  if (values.output) {
+    runtime.fsSync.writeFileSync(resolve(values.output), line);
+  } else {
+    runtime.proc.stdout.write(line);
+  }
+  return grade.verdict === "pass"
+    ? { ok: true }
+    : { ok: false, code: 1, error: "" };
+}

package/src/commands/benchmark-report.js

@@ -1,7 +1,9 @@
 /**
  * `fit-benchmark report` — aggregate `results.jsonl` into pass@k via the
  * OpenAI HumanEval estimator. Output is JSON by default; pass --format=text
- * to render a markdown table.
+ * to render a markdown table. --detail=compact drops the per-task detail
+ * sections so a sharded run's per-shard summary stays short (the merge job
+ * renders the full report over the combined ledger).
  */
 
 import { resolve } from "node:path";
@@ -35,11 +37,19 @@ export async function runBenchmarkReportCommand(ctx) {
   if (format !== "json" && format !== "text") {
     return { ok: false, code: 1, error: "--format must be 'json' or 'text'" };
   }
+  const detail = values.detail ?? "full";
+  if (detail !== "full" && detail !== "compact") {
+    return {
+      ok: false,
+      code: 1,
+      error: "--detail must be 'full' or 'compact'",
+    };
+  }
 
   const report = await aggregate({
     inputDir: resolve(inputDir),
     kValues,
-    includeRuns: format === "text",
+    includeRuns: format === "text" && detail === "full",
     runtime,
   });
   if (format === "text") {

package/src/commands/discuss.js

@@ -3,6 +3,7 @@ import { isoTimestamp } from "@forwardimpact/libutil";
 import { createDiscusser } from "../discusser.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
+import { parseAdvisorOptions } from "./advisor-flags.js";
 import { resolveTaskContent } from "./task-input.js";
 import { resolveWorkTracker } from "./work-tracker.js";
 import { AGENT_MODEL, LEAD_MODEL } from "@forwardimpact/libutil/models";
@@ -67,6 +68,7 @@ export function parseDiscussOptions(values, runtime) {
     callbackUrl: runtime.proc.env.CALLBACK_URL ?? null,
     inboxUrl: runtime.proc.env.INBOX_URL ?? null,
     correlationId: runtime.proc.env.CORRELATION_ID ?? null,
+    ...parseAdvisorOptions(values),
   };
 }
 
@@ -121,6 +123,8 @@ export async function runDiscussCommand(ctx) {
     inboxUrl: opts.inboxUrl,
     correlationId: opts.correlationId,
     runtime,
+    advisorModel: opts.advisorModel,
+    advisorMaxUses: opts.advisorMaxUses,
   });
 
   const result = await discusser.run(opts.taskContent);

package/src/commands/facilitate.js

@@ -3,6 +3,7 @@ import { isoTimestamp } from "@forwardimpact/libutil";
 import { createFacilitator } from "../facilitator.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
+import { parseAdvisorOptions } from "./advisor-flags.js";
 import { resolveTaskContent } from "./task-input.js";
 import { resolveWorkTracker } from "./work-tracker.js";
 import { AGENT_MODEL, LEAD_MODEL } from "@forwardimpact/libutil/models";
@@ -60,6 +61,7 @@ export function parseFacilitateOptions(values, runtime) {
     outputPath: values.output,
     facilitatorProfile: values["lead-profile"] || undefined,
     workTracker: resolveWorkTracker(values, runtime?.proc?.env),
+    ...parseAdvisorOptions(values),
   };
 }
 
@@ -112,6 +114,8 @@ export async function runFacilitateCommand(ctx) {
     taskAmend: opts.taskAmend,
     redactor,
     runtime,
+    advisorModel: opts.advisorModel,
+    advisorMaxUses: opts.advisorMaxUses,
   });
 
   const result = await facilitator.run(opts.taskContent);

package/src/commands/run.js

@@ -1,11 +1,23 @@
 import { Writable } from "node:stream";
 import { resolve } from "node:path";
 import { isoTimestamp } from "@forwardimpact/libutil";
+import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 import { createAgentRunner } from "../agent-runner.js";
-import { composeProfilePrompt } from "../profile-prompt.js";
+import {
+  advisorGuidance,
+  createAdvisor,
+  createAdvisorBudget,
+} from "../advisor.js";
+import { advisorTool } from "../orchestration-toolkit.js";
+import {
+  composeProfilePrompt,
+  composeSystemPrompt,
+} from "../profile-prompt.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
+import { createTranscriptRecorder } from "../transcript-recorder.js";
 import { SequenceCounter } from "../sequence-counter.js";
+import { parseAdvisorOptions } from "./advisor-flags.js";
 import { resolveWorkTracker } from "./work-tracker.js";
 import { resolveTaskContent } from "./task-input.js";
 import { createServiceConfig } from "@forwardimpact/libconfig";
@@ -15,7 +27,7 @@ import { AGENT_MODEL } from "@forwardimpact/libutil/models";
  * Parse and validate run command options from parsed values.
  * @param {object} values - Parsed option values from cli.parse()
  * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
- * @returns {{ taskContent: string, cwd: string, model: string, maxTurns: number, outputPath: string|undefined, agentProfile: string|undefined, workTracker: string, allowedTools: string[] }}
+ * @returns {{ taskContent: string, taskAmend: string|undefined, cwd: string, agentModel: string, maxTurns: number, outputPath: string|undefined, agentProfile: string|undefined, workTracker: string, allowedTools: string[], mcpServer: string|undefined, advisorModel: string|undefined, advisorMaxUses: number }}
  */
 export function parseRunOptions(values, runtime) {
   const { task: taskContent, amend: taskAmend } = resolveTaskContent(
@@ -40,9 +52,148 @@ export function parseRunOptions(values, runtime) {
       "Bash,Read,Glob,Grep,Write,Edit,Agent,TodoWrite"
     ).split(","),
     mcpServer: values["mcp-server"] || undefined,
+    ...parseAdvisorOptions(values),
   };
 }
 
+const devNull = new Writable({
+  write(_chunk, _enc, cb) {
+    cb();
+  },
+});
+
+/**
+ * Wire the run-mode agent session: external MCP entry, `LIBHARNESS_*` env
+ * writes, system-prompt composition, and — when an advisor model is set —
+ * the advisor wiring (budget, recorder, advisor session, dedicated MCP
+ * server holding only the `Advisor` tool). Extracted from `runRunCommand`
+ * so tests can inject a fake `query`.
+ *
+ * Run mode has no stop path (the command simply awaits the runner), so the
+ * consult timeout is deliberately the advisor's only guard.
+ *
+ * @param {object} deps
+ * @param {ReturnType<typeof parseRunOptions>} deps.opts
+ * @param {import("../redaction.js").Redactor} deps.redactor
+ * @param {import("stream").Writable} deps.output - Envelope NDJSON sink.
+ * @param {SequenceCounter} deps.counter
+ * @param {function} deps.query - SDK query function.
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} deps.runtime
+ * @returns {Promise<{runner: import("../agent-runner.js").AgentRunner, advisor: object|null}>}
+ */
+export async function wireRunSession({
+  opts,
+  redactor,
+  output,
+  counter,
+  query,
+  runtime,
+}) {
+  const emitEnvelope = (source, event) => {
+    output.write(
+      JSON.stringify(
+        redactor.redactValue({ source, seq: counter.next(), event }),
+      ) + "\n",
+    );
+  };
+  const onLine = (line) => emitEnvelope("agent", JSON.parse(line));
+
+  let mcpServers = null;
+  const allowedTools = opts.allowedTools;
+  if (opts.mcpServer) {
+    const mcpConfig = await createServiceConfig("mcp");
+    mcpServers = {
+      [opts.mcpServer]: {
+        type: "http",
+        url: mcpConfig.url,
+        headers: { Authorization: `Bearer ${mcpConfig.mcpToken()}` },
+      },
+    };
+    allowedTools.push(`mcp__${opts.mcpServer}__*`);
+  }
+
+  if (opts.agentProfile) {
+    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = opts.agentProfile;
+  }
+  // Unconditional so the default "github" is observable to the agent's
+  // active-tracker resolution, mirroring --agent-profile's env write above.
+  runtime.proc.env.LIBHARNESS_WORK_TRACKER = opts.workTracker;
+
+  // With a profile, the consult guidance rides the profile composer's
+  // amendment parameter; with no profile, a preset-append prompt carries
+  // the guidance as its only session-protocol fragment. Advisor off and no
+  // profile means no system prompt — today's behavior, unchanged.
+  let systemPrompt;
+  if (opts.agentProfile) {
+    systemPrompt = composeProfilePrompt(opts.agentProfile, {
+      profilesDir: resolve(opts.cwd, ".claude/agents"),
+      runtime,
+      ...(opts.advisorModel && {
+        amend: advisorGuidance(opts.advisorMaxUses),
+      }),
+    });
+  } else if (opts.advisorModel) {
+    systemPrompt = composeSystemPrompt({
+      role: "agent",
+      trailer: advisorGuidance(opts.advisorMaxUses),
+      runtime,
+    });
+  }
+
+  let advisor = null;
+  let recorder = null;
+  if (opts.advisorModel) {
+    const budget = createAdvisorBudget(opts.advisorMaxUses);
+    recorder = createTranscriptRecorder({ systemPrompt, redactor });
+    advisor = createAdvisor({
+      model: opts.advisorModel,
+      cwd: opts.cwd,
+      query,
+      recorder,
+      redactor,
+      runtime,
+      onLine: (line) => emitEnvelope("advisor", JSON.parse(line)),
+    });
+    const advTool = advisorTool({
+      from: "agent",
+      consult: (q) => advisor.consult(q),
+      emit: (event) => emitEnvelope("orchestrator", event),
+      budget,
+      model: opts.advisorModel,
+    });
+    // No allowlist push: in-process SDK MCP servers work under
+    // bypassPermissions without allowlist entries (loop-mode precedent).
+    mcpServers = {
+      ...mcpServers,
+      advisor: createSdkMcpServer({ name: "advisor", tools: [advTool] }),
+    };
+  }
+
+  const runner = createAgentRunner({
+    cwd: opts.cwd,
+    query,
+    output: devNull,
+    model: opts.agentModel,
+    maxTurns: opts.maxTurns,
+    allowedTools,
+    onLine: recorder
+      ? (line) => {
+          onLine(line);
+          recorder.recordMessage(line);
+        }
+      : onLine,
+    ...(recorder && { onPrompt: (text) => recorder.recordPrompt(text) }),
+    settingSources: ["project"],
+    systemPrompt,
+    taskAmend: opts.taskAmend,
+    mcpServers,
+    redactor,
+    runtime,
+  });
+
+  return { runner, advisor };
+}
+
 /**
  * Run command — execute a single agent via the Claude Agent SDK.
  *
@@ -53,18 +204,7 @@ export function parseRunOptions(values, runtime) {
  */
 export async function runRunCommand(ctx) {
   const runtime = ctx.deps.runtime;
-  const {
-    taskContent,
-    taskAmend,
-    cwd,
-    agentModel,
-    maxTurns,
-    outputPath,
-    agentProfile,
-    workTracker,
-    allowedTools,
-    mcpServer,
-  } = parseRunOptions(ctx.options, runtime);
+  const opts = parseRunOptions(ctx.options, runtime);
 
   // Build the redactor as the first observable side-effect after option
   // parsing — the env snapshot must freeze BEFORE any in-process
@@ -73,8 +213,8 @@ export async function runRunCommand(ctx) {
 
   // When --output is specified, stream text to stdout while writing NDJSON to file.
   // Otherwise, write NDJSON directly to stdout (backwards-compatible).
-  const fileStream = outputPath
-    ? runtime.fs.createWriteStream(outputPath)
+  const fileStream = opts.outputPath
+    ? runtime.fs.createWriteStream(opts.outputPath)
     : null;
   const output = fileStream
     ? createTeeWriter({
@@ -86,62 +226,17 @@ export async function runRunCommand(ctx) {
     : runtime.proc.stdout;
 
   const counter = new SequenceCounter();
-  const devNull = new Writable({
-    write(_chunk, _enc, cb) {
-      cb();
-    },
-  });
-  const onLine = (line) => {
-    const event = JSON.parse(line);
-    const tagged = { source: "agent", seq: counter.next(), event };
-    output.write(JSON.stringify(redactor.redactValue(tagged)) + "\n");
-  };
-
-  let mcpServers = null;
-  if (mcpServer) {
-    const mcpConfig = await createServiceConfig("mcp");
-    mcpServers = {
-      [mcpServer]: {
-        type: "http",
-        url: mcpConfig.url,
-        headers: { Authorization: `Bearer ${mcpConfig.mcpToken()}` },
-      },
-    };
-    allowedTools.push(`mcp__${mcpServer}__*`);
-  }
-
-  if (agentProfile) {
-    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = agentProfile;
-  }
-  // Unconditional so the default "github" is observable to the agent's
-  // active-tracker resolution, mirroring --agent-profile's env write above.
-  runtime.proc.env.LIBHARNESS_WORK_TRACKER = workTracker;
-
-  const systemPrompt = agentProfile
-    ? composeProfilePrompt(agentProfile, {
-        profilesDir: resolve(cwd, ".claude/agents"),
-        runtime,
-      })
-    : undefined;
-
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
-  const runner = createAgentRunner({
-    cwd,
-    query,
-    output: devNull,
-    model: agentModel,
-    maxTurns,
-    allowedTools,
-    onLine,
-    settingSources: ["project"],
-    systemPrompt,
-    taskAmend,
-    mcpServers,
+  const { runner } = await wireRunSession({
+    opts,
     redactor,
+    output,
+    counter,
+    query,
     runtime,
   });
 
-  const result = await runner.run(taskContent);
+  const result = await runner.run(opts.taskContent);
 
   if (fileStream) {
     await new Promise((r) => output.end(r));

package/src/commands/supervise.js

@@ -3,6 +3,7 @@ import { isoTimestamp } from "@forwardimpact/libutil";
 import { createSupervisor } from "../supervisor.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
+import { parseAdvisorOptions } from "./advisor-flags.js";
 import { resolveTaskContent } from "./task-input.js";
 import { resolveWorkTracker } from "./work-tracker.js";
 import { createServiceConfig } from "@forwardimpact/libconfig";
@@ -52,6 +53,7 @@ export async function parseSuperviseOptions(values, runtime) {
       ? supervisorAllowedToolsRaw.split(",")
       : undefined,
     mcpServer: values["mcp-server"] || undefined,
+    ...parseAdvisorOptions(values),
   };
 }
 
@@ -125,6 +127,8 @@ export async function runSuperviseCommand(ctx) {
     agentMcpServers,
     redactor,
     runtime,
+    advisorModel: opts.advisorModel,
+    advisorMaxUses: opts.advisorMaxUses,
   });
 
   const result = await supervisor.run(opts.taskContent);

package/src/discuss-tools.js

@@ -107,7 +107,7 @@ const ACKNOWLEDGE_DESC =
   "Acknowledge an Ask before starting work. Posts a visible comment on the thread. Does not discharge the Ask — you still owe an Answer.";
 
 /** Discuss-mode agent tool server. */
-export function createDiscussAgentToolServer(ctx, { from }) {
+export function createDiscussAgentToolServer(ctx, { from, extraTools = [] }) {
   return orchestrationServer([
     ...baseTools(ctx, { from, defaultTo: "lead", broadcast: true }),
     requestForCommentTool(ctx),
@@ -133,6 +133,7 @@ export function createDiscussAgentToolServer(ctx, { from }) {
         return { content: [{ type: "text", text: "Acknowledged." }] };
       },
     ),
+    ...extraTools,
   ]);
 }