@llamaventures/cli 1.14.0 → 1.14.1

package/CHANGELOG.md

@@ -6,6 +6,21 @@ this project adheres to [Semantic Versioning](https://semver.org).
 
 ## [Unreleased]
 
+## [1.14.1] — 2026-06-15
+
+### Added
+- **`llama deal agent run <dealId> --message "..."`** — starts Llama
+  Command's server-side Deal Agent in a deal thread, so the service agent can
+  execute deal-scoped work instead of the local CLI user doing it.
+- **`deal_agent_run` MCP tool** — the same narrow server-agent trigger for
+  MCP-native clients, without adding a generic API passthrough.
+
+### Changed
+- **`llama deal enrich <dealId> --apply --executor server_agent`** now starts
+  the server-side Deal Agent unless `--harness-only` is supplied. Dry-runs and
+  external-agent handoff prompts still use the enrichment harness endpoint.
+- **`deal_enrich` MCP tool** now mirrors the same behavior with `harnessOnly`.
+
 ## [1.14.0] — 2026-06-15
 
 ### Added

package/CONTRIBUTING.md

@@ -13,6 +13,7 @@ npm ci
 node bin/llama.mjs --help        # CLI is ESM, runs straight from source
 node --check bin/llama.mjs        # syntax check
 node --check bin/llama-mcp.mjs    # syntax check
+npm test                          # mock-backed CLI/MCP agent routing checks
 ```
 
 To test the CLI end-to-end against your own credentials, point it at the
@@ -33,8 +34,8 @@ printf '%s\n' \
   | node bin/llama-mcp.mjs | head -200
 ```
 
-You should see 51 named tools, including `deal_enrich`, the 5 `pitch_*`, and
-no generic API passthrough tool.
+You should see 52 named tools, including `deal_agent_run`, `deal_enrich`, the
+5 `pitch_*`, and no generic API passthrough tool.
 
 ## Conventions
 

package/README.md

@@ -48,7 +48,7 @@
 ```
 @llamaventures/cli
 ├── bin/llama          interactive CLI for humans + bash
-└── bin/llama-mcp      stdio MCP server, 51 typed tools — for any MCP-native agent
+└── bin/llama-mcp      stdio MCP server, 52 typed tools — for any MCP-native agent
 ```
 
 Both binaries share `lib/client.mjs` — the **same** auth chain, **same** HTTP
@@ -187,7 +187,9 @@ llama deal show <dealId>
 llama deal create "Acme AI" --description "..." --source Gavin
 llama deal update <dealId> status Diligence
 llama deal enrich <dealId> --dry-run
+llama deal enrich <dealId> --apply --executor server_agent
 llama deal enrich <dealId> --executor external_agent --prompt
+llama deal agent run <dealId> --message "collect founder evidence and update typed facts"
 llama deal delete  <dealId>     # soft (audit-logged)
 llama deal restore <dealId>
 
@@ -247,13 +249,14 @@ agents can pattern-match without parsing prose.
 ## MCP server
 
 The bundled `llama-mcp` is a **stdio Model Context Protocol** server exposing
-**51 typed tools** that mirror the most-used CLI surface. Every tool is named
+**52 typed tools** that mirror the most-used CLI surface. Every tool is named
 and scoped — there is no generic API passthrough, by design (a public-package
 escape hatch reachable from a prompt-injectable agent context is exactly the
 shape we want to avoid).
 
 Coverage is grouped around the workflows agents actually need: auth
-diagnostics; deal search/show/create/update/feed; deal enrichment harnesses;
+diagnostics; deal search/show/create/update/feed; server-side deal agent runs;
+deal enrichment harnesses;
 trust-rated facts; brief blocks and version history; wiki read/write/delete/restore;
 timeline posts and mentions; skill corrections; refresh triggers; external pitch intake;
 memo show/regenerate/save/reset; and deal-scoped HTML docs, versions, bundles, and

package/README.zh-CN.md

@@ -48,7 +48,7 @@
 ```
 @llamaventures/cli
 ├── bin/llama          给人 + bash 用的交互式 CLI
-└── bin/llama-mcp      给 MCP 原生 agent 用的 stdio MCP server，51 个工具
+└── bin/llama-mcp      给 MCP 原生 agent 用的 stdio MCP server，52 个工具
 ```
 
 两个 binary 共享 `lib/client.mjs`——**同一**认证链、**同一** HTTP 客户端、
@@ -208,7 +208,9 @@ llama deal show <dealId>
 llama deal create "Acme AI" --description "..." --source Gavin
 llama deal update <dealId> status Diligence
 llama deal enrich <dealId> --dry-run
+llama deal enrich <dealId> --apply --executor server_agent
 llama deal enrich <dealId> --executor external_agent --prompt
+llama deal agent run <dealId> --message "collect founder evidence and update typed facts"
 llama deal delete  <dealId>     # 软删除（审计日志记录）
 llama deal restore <dealId>
 
@@ -259,12 +261,12 @@ MCP server 在 `isError: true` 内容里返回相同的前缀，agent 不用解
 ## MCP server
 
 随包发布的 `llama-mcp` 是一个 **stdio Model Context Protocol** server，
-暴露 **51 个 typed tools**——基本镜像 CLI 最常用的命令。每个 tool 都是
+暴露 **52 个 typed tools**——基本镜像 CLI 最常用的命令。每个 tool 都是
 具名、scoped 的；**没有**通用的 API passthrough，这是有意设计的（公开
 package 里一个能被 prompt-injection 触达的逃生通道，正是我们要避开的形状）。
 
 覆盖面按 agent 真正会用的工作流分组：auth 诊断；deal search/show/create/
-update/feed；deal enrichment harness；带 trust ladder 的事实；brief blocks
+update/feed；服务端 deal agent run；deal enrichment harness；带 trust ladder 的事实；brief blocks
 和版本历史；wiki 读写删恢复；timeline posts 和 mentions；skill corrections；
 refresh triggers；外部 pitch intake；memo show/regenerate/save/reset；
 以及 deal-scoped HTML docs、versions、bundles、restore/reset。

package/bin/llama-mcp.mjs

@@ -11,7 +11,7 @@ import { createRequire } from "module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { getAuthHeaders, readBriefing, request } from "../lib/client.mjs";
+import { getAuthHeaders, readBriefing, request, requestSse } from "../lib/client.mjs";
 
 const requireFromHere = createRequire(import.meta.url);
 const { version: PKG_VERSION } = requireFromHere("../package.json");
@@ -40,6 +40,96 @@ async function callApi(method, path, body) {
   }
 }
 
+function textResult(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+function splitSources(value) {
+  if (Array.isArray(value)) return value.filter(Boolean);
+  if (!value || value === true) return undefined;
+  return String(value)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function buildEnrichmentAgentMessage(args = {}) {
+  if (args.message) return String(args.message);
+  const sources = splitSources(args.sources) ?? [
+    "website",
+    "github",
+    "linkedin",
+    "yc",
+    "launch",
+    "web",
+    "monid",
+  ];
+  const budget = args.budgetCents ?? "50";
+  const memo = args.generateMemo
+    ? "Generate memo only after enrichment because the caller explicitly requested it."
+    : "Do not generate memo.";
+  return [
+    "Run server-side deal enrichment for this deal.",
+    `Use sources: ${sources.join(", ")}.`,
+    `Private Monid budget cap: ${budget} cents.`,
+    "Read the enrichment harness first, then collect current company/founder evidence.",
+    "Write canonical evidence links, sourced deal facts, stable deal fields, and typed factual values where supported.",
+    "For typed factual values, call read_typed_factual_layer first and use upsert_typed_fact for queryable fields.",
+    "Search snippets alone are not high-confidence evidence; fetch direct sources where possible.",
+    memo,
+    "End with what was written, what was skipped, and open questions.",
+  ].join(" ");
+}
+
+function summarizeAgentEvents(events = []) {
+  return events
+    .flatMap((event) => {
+      if (event.tool_use?.name) return [{ type: "tool_use", name: event.tool_use.name }];
+      if (event.tool_result?.name) {
+        return [
+          {
+            type: "tool_result",
+            name: event.tool_result.name,
+            ok: event.tool_result.ok ?? null,
+            summary: event.tool_result.summary ?? null,
+          },
+        ];
+      }
+      if (event.error) return [{ type: "error", error: String(event.error) }];
+      return [];
+    })
+    .slice(-80);
+}
+
+async function runDealAgentTool({ dealId, message, title = "MCP agent run" }) {
+  try {
+    const thread = await request("POST", `/api/deals/${encodeURIComponent(dealId)}/threads`, { title });
+    if (!thread?.id) throw new Error("Thread creation did not return an id");
+    const result = await requestSse(
+      "POST",
+      `/api/deals/${encodeURIComponent(dealId)}/threads/${encodeURIComponent(thread.id)}`,
+      { message },
+    );
+    return textResult(
+      JSON.stringify(
+        {
+          ok: true,
+          threadId: thread.id,
+          text: result.text,
+          toolEvents: summarizeAgentEvents(result.events),
+        },
+        null,
+        2,
+      ),
+    );
+  } catch (err) {
+    return textResult(`Error: ${err?.message ?? String(err)}`, true);
+  }
+}
+
 // Append a block to a deal brief. The /blocks route only accepts atomic
 // full-array PUTs (no POST), so we GET current blocks, prepend the new
 // one (matches UI default since 2026-05-03), and PUT the merged array.
@@ -786,14 +876,33 @@ server.registerTool(
     callApi("POST", `/api/deals/${encodeURIComponent(dealId)}/refresh-persona`, { persona })
 );
 
+server.registerTool(
+  "deal_agent_run",
+  {
+    description:
+      "Run Llama Command's server-side Deal Agent inside a deal thread. " +
+      "Use this when the user explicitly wants the service agent to execute " +
+      "a deal-scoped task instead of the local MCP client doing the work.",
+    inputSchema: {
+      dealId: z.string().describe("deal uuid"),
+      message: z.string().describe("task instruction for the server-side Deal Agent"),
+      title: z.string().optional().describe("optional thread title; defaults to MCP agent run"),
+    },
+  },
+  async ({ dealId, message, title }) =>
+    runDealAgentTool({ dealId, message, title: title || "MCP agent run" })
+);
+
 server.registerTool(
   "deal_enrich",
   {
     description:
       "Run the Llama Command deal enrichment planner/trigger for one deal. " +
       "Default is dry-run: returns evidence plan, source plan, Monid budget/config " +
-      "status, and planned writes without changing facts/links/memo. Set apply=true " +
-      "only when the user explicitly wants the enrichment run recorded/applied. " +
+      "status, and planned writes without changing facts/links/memo. With " +
+      "apply=true and executor=server_agent, this starts the server-side Deal " +
+      "Agent unless harnessOnly=true. Set apply=true only when the user " +
+      "explicitly wants the enrichment run recorded/applied. " +
       "generateMemo never defaults on; pass true only when the user explicitly asks " +
       "for Memo generation after enrichment.",
     inputSchema: {
@@ -803,7 +912,7 @@ server.registerTool(
       executor: z
         .enum(["server_agent", "external_agent", "planner"])
         .optional()
-        .describe("who will execute the harness; external_agent returns guardrails for a user-owned agent"),
+        .describe("who will execute the harness; server_agent starts Deal Agent when apply=true"),
       sources: z
         .array(z.enum(["website", "github", "linkedin", "yc", "launch", "web", "monid"]))
         .optional()
@@ -819,17 +928,34 @@ server.registerTool(
         .boolean()
         .optional()
         .describe("explicitly request memo regeneration after enrichment; default false"),
+      harnessOnly: z
+        .boolean()
+        .optional()
+        .describe("when true, return/apply the enrichment harness endpoint instead of starting Deal Agent"),
+      message: z
+        .string()
+        .optional()
+        .describe("optional override instruction for the server-side Deal Agent"),
     },
   },
-  async ({ dealId, dryRun, apply, executor, sources, budgetCents, generateMemo }) =>
-    callApi("POST", `/api/deals/${encodeURIComponent(dealId)}/enrich`, {
+  async ({ dealId, dryRun, apply, executor, sources, budgetCents, generateMemo, harnessOnly, message }) => {
+    const effectiveExecutor = executor ?? "server_agent";
+    if (apply === true && effectiveExecutor === "server_agent" && harnessOnly !== true) {
+      return runDealAgentTool({
+        dealId,
+        title: "MCP enrichment",
+        message: buildEnrichmentAgentMessage({ sources, budgetCents, generateMemo, message }),
+      });
+    }
+    return callApi("POST", `/api/deals/${encodeURIComponent(dealId)}/enrich`, {
       dryRun,
       apply,
-      executor,
+      executor: effectiveExecutor,
       sources,
       budgetCents,
       generateMemo,
-    })
+    });
+  }
 );
 
 // ============================================================

package/bin/llama.mjs

@@ -15,6 +15,7 @@ import {
   readCanonicalToken,
   readLegacyConfig,
   request,
+  requestSse,
   tryGcloudIdentityToken,
   writeCanonicalToken,
   writeLegacyConfig,
@@ -199,6 +200,75 @@ async function searchDeals(q, flags) {
   return result;
 }
 
+function splitCsvFlag(value) {
+  if (!value || value === true) return undefined;
+  return String(value)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function boolFlag(flags, ...names) {
+  return names.some((name) => flags[name] === true || flags[name] === "true" || flags[name] === "1");
+}
+
+function buildEnrichmentAgentMessage(flags) {
+  if (flags.message && flags.message !== true) return String(flags.message);
+  const sources = splitCsvFlag(flags.sources) ?? [
+    "website",
+    "github",
+    "linkedin",
+    "yc",
+    "launch",
+    "web",
+    "monid",
+  ];
+  const budget = flags["budget-cents"] || flags.budgetCents || "50";
+  const memo = boolFlag(flags, "memo", "generate-memo", "generateMemo")
+    ? "Generate memo only after enrichment because the caller explicitly requested it."
+    : "Do not generate memo.";
+  return [
+    "Run server-side deal enrichment for this deal.",
+    `Use sources: ${sources.join(", ")}.`,
+    `Private Monid budget cap: ${budget} cents.`,
+    "Read the enrichment harness first, then collect current company/founder evidence.",
+    "Write canonical evidence links, sourced deal facts, stable deal fields, and typed factual values where supported.",
+    "For typed factual values, call read_typed_factual_layer first and use upsert_typed_fact for queryable fields.",
+    "Search snippets alone are not high-confidence evidence; fetch direct sources where possible.",
+    memo,
+    "End with what was written, what was skipped, and open questions.",
+  ].join(" ");
+}
+
+async function runDealAgentViaThread(dealId, message, title = "CLI agent run") {
+  const thread = await request("POST", `/api/deals/${encodeURIComponent(dealId)}/threads`, { title });
+  if (!thread?.id) throw new Error("Thread creation did not return an id");
+  process.stderr.write(`Running Deal Agent in thread ${thread.id}\n`);
+  const result = await requestSse(
+    "POST",
+    `/api/deals/${encodeURIComponent(dealId)}/threads/${encodeURIComponent(thread.id)}`,
+    { message },
+    {
+      onEvent(event) {
+        if (event.tool_use?.name) {
+          process.stderr.write(`[tool] ${event.tool_use.name}\n`);
+        }
+        if (event.tool_result?.name) {
+          const status = event.tool_result.ok ? "ok" : "error";
+          process.stderr.write(
+            `[tool] ${event.tool_result.name}: ${status} — ${event.tool_result.summary ?? ""}\n`,
+          );
+        }
+        if (event.text) {
+          process.stdout.write(event.text);
+        }
+      },
+    },
+  );
+  if (result.text && !result.text.endsWith("\n")) process.stdout.write("\n");
+  return { thread, ...result };
+}
+
 const HELP_FULL = `Llama Command CLI
 
 Agent onboarding (run once on first install):
@@ -237,7 +307,9 @@ Deals:
             llama deal update <dealId> leadInvestor "Acme Capital"
   llama deal enrich <dealId> [--dry-run] [--apply] [--executor server_agent|external_agent|planner]
                             [--sources website,github,linkedin,yc,monid] [--budget-cents 50]
-                            [--memo] [--prompt]                # evidence harness + server-side enrichment trigger
+                            [--memo] [--prompt] [--harness-only]
+      dry-run returns the harness; --apply --executor server_agent runs the server Deal Agent.
+  llama deal agent run <dealId> --message "collect founder evidence and update typed facts"
   llama deal extra set <dealId> <key> <value>        # system-admin only
       Patch one top-level key in deals.extra JSONB. Value is parsed as
       JSON when possible ('{"a":1}', 'true', '3'), else stored as a
@@ -1160,6 +1232,19 @@ https://command.llamaventures.vc/settings/tokens, run
     return;
   }
 
+  if (area === "deal" && action === "agent") {
+    const sub = rest[0];
+    const dealId = rest[1];
+    const { flags, positional } = parseFlags(rest.slice(2), ["message"]);
+    const message =
+      flags.message && flags.message !== true ? String(flags.message) : positional.join(" ").trim();
+    if (sub !== "run" || !dealId || !message) {
+      throw new Error(`Usage: llama deal agent run <dealId> --message "what the server agent should do"`);
+    }
+    await runDealAgentViaThread(dealId, message, "CLI agent run");
+    return;
+  }
+
   // ----- Deal enrichment: evidence plan + server-side enrichment trigger -----
   // The server owns Monid credentials and all write/audit behavior. CLI only
   // passes intent; default is dry-run so agents can inspect the harness before
@@ -1181,31 +1266,35 @@ https://command.llamaventures.vc/settings/tokens, run
       "budget-cents",
       "memo",
       "generate-memo",
+      "generateMemo",
       "prompt",
       "handoff",
+      "harness-only",
+      "message",
     ]);
-    const sources =
-      flags.sources && flags.sources !== true
-        ? String(flags.sources)
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean)
-        : undefined;
+    const sources = splitCsvFlag(flags.sources);
     const budgetCents =
       flags["budget-cents"] !== undefined && flags["budget-cents"] !== true
         ? Number(flags["budget-cents"])
         : undefined;
+    const apply = boolFlag(flags, "apply");
+    const executor = flags.executor && flags.executor !== true ? String(flags.executor) : "server_agent";
+
+    if (apply && executor === "server_agent" && !boolFlag(flags, "harness-only")) {
+      await runDealAgentViaThread(dealId, buildEnrichmentAgentMessage(flags), "CLI enrichment");
+      return;
+    }
 
     const result = await request(
       "POST",
       `/api/deals/${encodeURIComponent(dealId)}/enrich`,
       {
-        dryRun: flags.apply === true ? false : true,
-        apply: flags.apply === true,
-        executor: flags.executor && flags.executor !== true ? String(flags.executor) : undefined,
+        dryRun: apply ? false : true,
+        apply,
+        executor,
         sources,
         budgetCents,
-        generateMemo: flags.memo === true || flags["generate-memo"] === true,
+        generateMemo: boolFlag(flags, "memo", "generate-memo", "generateMemo"),
       }
     );
     if (flags.prompt === true || flags.handoff === true) {

package/lib/client.mjs

@@ -220,6 +220,10 @@ export async function request(method, endpoint, body) {
   return requestWithRetry(method, endpoint, body, /* allowRetry */ true);
 }
 
+export async function requestSse(method, endpoint, body, opts = {}) {
+  return requestSseWithRetry(method, endpoint, body, opts, /* allowRetry */ true);
+}
+
 async function requestWithRetry(method, endpoint, body, allowRetry) {
   const authHeaders = await getAuthHeaders();
   if (Object.keys(authHeaders).length === 0) throw noAuthError();
@@ -268,6 +272,80 @@ async function requestWithRetry(method, endpoint, body, allowRetry) {
   return data;
 }
 
+async function requestSseWithRetry(method, endpoint, body, opts, allowRetry) {
+  const authHeaders = await getAuthHeaders();
+  if (Object.keys(authHeaders).length === 0) throw noAuthError();
+  const res = await fetch(`${getBaseUrl()}${endpoint}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...authHeaders,
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+
+  if (res.status === 401 && allowRetry && (await bearerCameFromOAuth())) {
+    let refreshed = null;
+    try {
+      const { forceRefresh } = await import("./oauth-refresh.mjs");
+      refreshed = await forceRefresh();
+    } catch {
+      refreshed = null;
+    }
+    if (refreshed) {
+      return requestSseWithRetry(method, endpoint, body, opts, /* allowRetry */ false);
+    }
+    throw unauthorizedError();
+  }
+
+  if (res.status === 401) throw unauthorizedError();
+
+  if (!res.ok) {
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = text;
+    }
+    const message = typeof data === "object" && data?.error ? data.error : `HTTP ${res.status}`;
+    throw new Error(message);
+  }
+
+  const reader = res.body?.getReader();
+  const decoder = new TextDecoder();
+  const events = [];
+  let text = "";
+  let buf = "";
+  if (!reader) return { text, events };
+
+  const handleFrame = (frame) => {
+    const dataLine = frame.split("\n").find((line) => line.startsWith("data: "));
+    if (!dataLine) return;
+    let event;
+    try {
+      event = JSON.parse(dataLine.slice(6));
+    } catch {
+      return;
+    }
+    events.push(event);
+    opts.onEvent?.(event);
+    if (event.text) text += event.text;
+    if (event.error) throw new Error(String(event.error));
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const frames = buf.split("\n\n");
+    buf = frames.pop() || "";
+    for (const frame of frames) handleFrame(frame);
+  }
+  if (buf.trim()) handleFrame(buf);
+  return { text, events };
+}
+
 export function print(data) {
   if (typeof data === "string") {
     console.log(data);

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@llamaventures/cli",
-  "version": "1.14.0",
+  "version": "1.14.1",
   "description": "CLI + MCP server for the Llama Ventures investment workbench (command.llamaventures.vc).",
   "type": "module",
+  "scripts": {
+    "test": "npm run test:agent-routing",
+    "test:agent-routing": "node scripts/verify-agent-routing.mjs"
+  },
   "bin": {
     "llama": "bin/llama.mjs",
     "llama-mcp": "bin/llama-mcp.mjs"
@@ -11,6 +15,7 @@
     "assets/",
     "bin/",
     "lib/",
+    "scripts/verify-agent-routing.mjs",
     "AGENT_BRIEFING.md",
     "CHANGELOG.md",
     "CONTRIBUTING.md",

package/scripts/verify-agent-routing.mjs

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const calls = [];
+let threadSeq = 0;
+
+async function readJson(req) {
+  let raw = "";
+  for await (const chunk of req) raw += chunk;
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function writeJson(res, data) {
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+function writeSse(res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  });
+  const events = [
+    { tool_use: { name: "read_typed_factual_layer" } },
+    { tool_result: { name: "read_typed_factual_layer", ok: true, summary: "ok" } },
+    { text: "agent done" },
+  ];
+  for (const event of events) {
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+  }
+  res.end();
+}
+
+const server = createServer(async (req, res) => {
+  try {
+    const body = await readJson(req);
+    const url = new URL(req.url, "http://localhost");
+    calls.push({ method: req.method, path: url.pathname, body });
+
+    if (req.method === "POST" && /^\/api\/deals\/[^/]+\/threads$/.test(url.pathname)) {
+      threadSeq += 1;
+      writeJson(res, { id: `thread-${threadSeq}` });
+      return;
+    }
+
+    if (req.method === "POST" && /^\/api\/deals\/[^/]+\/threads\/[^/]+$/.test(url.pathname)) {
+      writeSse(res);
+      return;
+    }
+
+    if (req.method === "POST" && /^\/api\/deals\/[^/]+\/enrich$/.test(url.pathname)) {
+      writeJson(res, {
+        ok: true,
+        agentHarness: {
+          handoffPrompt: "mock handoff prompt",
+          systemInjection: "mock system injection",
+        },
+      });
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: `Unexpected route ${req.method} ${url.pathname}` }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: err?.message ?? String(err) }));
+  }
+});
+
+function listen(server) {
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+}
+
+function close(server) {
+  return new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+function childEnv(baseUrl, homeDir) {
+  return {
+    ...process.env,
+    HOME: homeDir,
+    LLAMA_API_URL: baseUrl,
+    LLAMA_TOKEN: "llc_mock_agent_routing",
+    PATH: "/usr/bin:/bin",
+  };
+}
+
+function resetCalls() {
+  calls.length = 0;
+  threadSeq = 0;
+}
+
+function paths() {
+  return calls.map((call) => `${call.method} ${call.path}`);
+}
+
+function assertNoEnrichCall() {
+  assert.equal(
+    calls.some((call) => call.path.endsWith("/enrich")),
+    false,
+    `expected no /enrich call, got ${paths().join(", ")}`,
+  );
+}
+
+function assertThreadRun({ title, messageIncludes }) {
+  assert.equal(calls.length, 2, `expected thread create + SSE run, got ${paths().join(", ")}`);
+  assert.match(calls[0].path, /^\/api\/deals\/[^/]+\/threads$/);
+  assert.equal(calls[0].body?.title, title);
+  assert.match(calls[1].path, /^\/api\/deals\/[^/]+\/threads\/thread-1$/);
+  for (const needle of messageIncludes) {
+    assert.match(calls[1].body?.message ?? "", new RegExp(escapeRegExp(needle)));
+  }
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function runCli(args, baseUrl, homeDir) {
+  const child = spawn(process.execPath, ["bin/llama.mjs", ...args], {
+    cwd: repoRoot,
+    env: childEnv(baseUrl, homeDir),
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  const code = await new Promise((resolve) => child.on("close", resolve));
+  assert.equal(code, 0, `CLI failed (${code})\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+  return { stdout, stderr };
+}
+
+async function callMcpTool(name, args, baseUrl, homeDir) {
+  const child = spawn(process.execPath, ["bin/llama-mcp.mjs"], {
+    cwd: repoRoot,
+    env: childEnv(baseUrl, homeDir),
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  let stderr = "";
+  let buffer = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+
+  const result = await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(new Error(`Timed out waiting for MCP response\nSTDERR:\n${stderr}`));
+    }, 8000);
+
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk;
+      let idx;
+      while ((idx = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (!line) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 2) {
+          clearTimeout(timeout);
+          child.kill();
+          resolve(msg);
+        }
+      }
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+
+    child.stdin.write(
+      [
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "routing-test", version: "1" },
+          },
+        }),
+        JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: 2,
+          method: "tools/call",
+          params: { name, arguments: args },
+        }),
+      ].join("\n") + "\n",
+    );
+  });
+
+  assert.ok(!result.error, `MCP returned error: ${JSON.stringify(result.error)}`);
+  return result.result;
+}
+
+await listen(server);
+const address = server.address();
+const baseUrl = `http://${address.address}:${address.port}`;
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "llama-cli-routing-"));
+
+try {
+  resetCalls();
+  const enrichRun = await runCli(
+    [
+      "deal",
+      "enrich",
+      "deal-cli",
+      "--apply",
+      "--executor",
+      "server_agent",
+      "--sources",
+      "website,monid",
+      "--budget-cents",
+      "12",
+    ],
+    baseUrl,
+    homeDir,
+  );
+  assert.match(enrichRun.stdout, /agent done/);
+  assertNoEnrichCall();
+  assertThreadRun({
+    title: "CLI enrichment",
+    messageIncludes: ["website, monid", "12 cents", "upsert_typed_fact"],
+  });
+
+  resetCalls();
+  await runCli(
+    ["deal", "enrich", "deal-cli", "--apply", "--executor", "server_agent", "--harness-only"],
+    baseUrl,
+    homeDir,
+  );
+  assert.deepEqual(paths(), ["POST /api/deals/deal-cli/enrich"]);
+  assert.equal(calls[0].body?.apply, true);
+  assert.equal(calls[0].body?.dryRun, false);
+  assert.equal(calls[0].body?.executor, "server_agent");
+
+  resetCalls();
+  const agentRun = await runCli(
+    ["deal", "agent", "run", "deal-cli", "--message", "custom server task"],
+    baseUrl,
+    homeDir,
+  );
+  assert.match(agentRun.stdout, /agent done/);
+  assertNoEnrichCall();
+  assertThreadRun({
+    title: "CLI agent run",
+    messageIncludes: ["custom server task"],
+  });
+
+  resetCalls();
+  const mcpResult = await callMcpTool(
+    "deal_enrich",
+    {
+      dealId: "deal-mcp",
+      apply: true,
+      executor: "server_agent",
+      sources: ["web", "monid"],
+      budgetCents: 7,
+    },
+    baseUrl,
+    homeDir,
+  );
+  assertNoEnrichCall();
+  assertThreadRun({
+    title: "MCP enrichment",
+    messageIncludes: ["web, monid", "7 cents", "upsert_typed_fact"],
+  });
+  const payload = JSON.parse(mcpResult.content?.[0]?.text ?? "{}");
+  assert.equal(payload.ok, true);
+  assert.equal(payload.threadId, "thread-1");
+  assert.equal(payload.text, "agent done");
+
+  console.log("agent routing verification passed");
+} finally {
+  await close(server);
+  await rm(homeDir, { recursive: true, force: true });
+}