forge-delegate 1.0.0

package/lib.mjs

@@ -0,0 +1,357 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const execFileAsync = promisify(execFile);
+export const OPENCODE_TIMEOUT = Number(process.env.FORGE_OPENCODE_TIMEOUT ?? 900_000);
+const CONFIG_DIR = join(homedir(), ".forge-delegate");
+const AUTH_PATH = join(homedir(), ".local/share/opencode/auth.json");
+const OPENCODE_CONFIG_PATH = join(homedir(), ".config/opencode/opencode.json");
+const CATALOG_CACHE = join(CONFIG_DIR, "models-dev.json");
+const CATALOG_TTL = 24 * 3600 * 1000;
+const VARIANTS_CACHE = join(CONFIG_DIR, "variants.json");
+const OLLAMA_BASE = process.env.OLLAMA_URL ?? "http://localhost:11434";
+
+function loadOpencodeAuth() {
+  try {
+    return JSON.parse(readFileSync(AUTH_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+async function loadCatalog() {
+  try {
+    const cached = JSON.parse(readFileSync(CATALOG_CACHE, "utf8"));
+    if (Date.now() - cached.fetchedAt < CATALOG_TTL && cached.data) return cached.data;
+  } catch {}
+  const res = await fetch("https://models.dev/api.json");
+  if (!res.ok) throw new Error(`models.dev ${res.status}`);
+  const data = await res.json();
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CATALOG_CACHE, JSON.stringify({ fetchedAt: Date.now(), data }));
+  } catch {}
+  return data;
+}
+
+export function logUsage(entry) {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    appendFileSync(join(CONFIG_DIR, "usage.jsonl"), JSON.stringify({ ts: Date.now(), ...entry }) + "\n");
+  } catch {}
+}
+
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export function defaultConfig() {
+  return {
+    defaultModel: null,
+    defaultAgent: null,
+    defaultVariant: null,
+    autoApprove: true,
+    timeoutMs: Number(process.env.FORGE_OPENCODE_TIMEOUT ?? 900_000),
+    defaultDirectory: null,
+    profiles: {},
+  };
+}
+
+export function loadConfig() {
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    return { ...defaultConfig(), ...raw, profiles: raw.profiles ?? {} };
+  } catch {
+    return defaultConfig();
+  }
+}
+
+export function saveConfig(patch = {}) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const next = { ...loadConfig(), ...patch };
+  writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+
+export function configPath() {
+  return CONFIG_PATH;
+}
+
+// Merge a single call's options with the active profile (if any) and config defaults.
+export function resolveConfig(overrides = {}) {
+  const cfg = loadConfig();
+  const profile = overrides.profile ? cfg.profiles?.[overrides.profile] ?? {} : {};
+  const o = { ...profile, ...overrides };
+  return {
+    model: o.model ?? cfg.defaultModel ?? null,
+    agent: o.agent ?? cfg.defaultAgent ?? null,
+    variant: o.variant ?? cfg.defaultVariant ?? null,
+    autoApprove: o.autoApprove ?? cfg.autoApprove,
+    timeoutMs: o.timeoutMs ?? cfg.timeoutMs,
+    directory: o.directory ?? cfg.defaultDirectory ?? null,
+  };
+}
+
+export function opencodeArgs(model, prompt, { files, sessionId, variant, directory, agent, autoApprove } = {}) {
+  const args = ["run", "--format", "json"];
+  if (autoApprove) args.push("--auto");
+  if (sessionId) args.push("-s", sessionId);
+  if (directory) args.push("--dir", directory);
+  if (agent) args.push("--agent", agent);
+  args.push("-m", model);
+  if (variant) args.push("--variant", variant);
+  for (const f of files ?? []) args.push("-f", f);
+  args.push(prompt);
+  return args;
+}
+
+export async function pickVariant(model) {
+  const [provider, ...rest] = model.split("/");
+  const id = rest.join("/");
+  if (!provider || !id || model.startsWith("ollama:")) return undefined;
+  let variants = {};
+  try {
+    variants = await loadVariantMap();
+  } catch {
+    return undefined;
+  }
+  const list = variants[`${provider}/${id}`];
+  if (!Array.isArray(list) || list.length === 0) return undefined;
+  return list.length === 1 ? list[0] : list[list.length - 2];
+}
+
+// Variant names per provider/model, discovered from `GET /config/providers`
+// on a short-lived local opencode server. Cached on disk for 24h.
+async function loadVariantMap() {
+  try {
+    const cached = JSON.parse(readFileSync(VARIANTS_CACHE, "utf8"));
+    if (Date.now() - cached.fetchedAt < CATALOG_TTL && cached.data) return cached.data;
+  } catch {}
+  const child = spawn("opencode", ["serve", "--port", "0"], { stdio: ["ignore", "pipe", "pipe"] });
+  try {
+    const baseUrl = await new Promise((resolvePromise, rejectPromise) => {
+      let out = "";
+      const timer = setTimeout(() => rejectPromise(new Error("opencode serve timed out")), 20_000);
+      child.stdout.on("data", (d) => {
+        out += d;
+        const m = out.match(/listening on (https?:\/\/\S+)/);
+        if (m) {
+          clearTimeout(timer);
+          resolvePromise(m[1]);
+        }
+      });
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        rejectPromise(e);
+      });
+      child.on("exit", () => {
+        clearTimeout(timer);
+        rejectPromise(new Error("opencode serve exited before listening"));
+      });
+    });
+    const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/config/providers`, { signal: AbortSignal.timeout(15_000) });
+    if (!res.ok) throw new Error(`config/providers ${res.status}`);
+    const body = await res.json();
+    const providers = body.providers ?? body;
+    const map = {};
+    for (const p of Array.isArray(providers) ? providers : Object.values(providers)) {
+      for (const [mid, m] of Object.entries(p.models ?? {})) {
+        if (m?.variants) map[`${p.id}/${mid}`] = Object.keys(m.variants);
+      }
+    }
+    try {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(VARIANTS_CACHE, JSON.stringify({ fetchedAt: Date.now(), data: map }));
+    } catch {}
+    return map;
+  } finally {
+    child.kill("SIGKILL");
+  }
+}
+
+export function parseEvents(stdout) {
+  let text = "";
+  let sessionId = null;
+  let tokens = 0;
+  for (const line of stdout.split("\n")) {
+    if (!line.startsWith("{")) continue;
+    try {
+      const ev = JSON.parse(line);
+      if (!sessionId && ev.sessionID) sessionId = ev.sessionID;
+      if (ev.type === "text" && ev.part?.text) text += (text ? "\n" : "") + ev.part.text;
+      if (ev.type === "step_finish" && ev.part?.tokens)
+        tokens += (ev.part.tokens.input ?? 0) + (ev.part.tokens.output ?? 0);
+    } catch {}
+  }
+  return { text: text.trim(), sessionId, tokens };
+}
+
+export async function opencodeRun(model, prompt, opts = {}) {
+  const started = Date.now();
+  const variant = opts.variant ?? (await pickVariant(model));
+  const timeoutMs = opts.timeoutMs ?? OPENCODE_TIMEOUT;
+  const cwd = opts.directory ?? process.cwd();
+  const stdout = await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn("opencode", opencodeArgs(model, prompt, { ...opts, variant }), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let out = "";
+    let errOut = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      rejectPromise(new Error(`opencode timed out after ${timeoutMs / 1000}s`));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", (d) => (errOut += d));
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      rejectPromise(e);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0 || out.trim()) resolvePromise(out);
+      else rejectPromise(new Error(`opencode exited ${code}: ${errOut.slice(-500) || "no output"}`));
+    });
+  });
+  const { text, sessionId, tokens } = parseEvents(stdout);
+  return { text: text || "(no output)", sessionId, tokens, ms: Date.now() - started };
+}
+
+export async function callDirect(baseUrl, model, messages, apiKey, extraBody = {}) {
+  const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+    },
+    body: JSON.stringify({ model, messages, ...extraBody }),
+  });
+  if (!res.ok) throw new Error(`API ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content;
+}
+
+export async function listAuthDirectProviders() {
+  const auth = loadOpencodeAuth();
+  let catalog = {};
+  try {
+    catalog = await loadCatalog();
+  } catch {}
+  return Object.entries(auth)
+    .filter(([, v]) => v?.key)
+    .map(([name]) => ({
+      name,
+      models: Object.keys(catalog[name]?.models ?? {}).slice(0, 10),
+      baseUrl: catalog[name]?.api ?? "(unknown)",
+    }));
+}
+
+// Custom providers defined in opencode.json (npm @ai-sdk/openai-compatible + baseURL)
+function loadOpencodeConfigProviders() {
+  try {
+    const cfg = JSON.parse(readFileSync(OPENCODE_CONFIG_PATH, "utf8"));
+    const out = {};
+    for (const [name, p] of Object.entries(cfg.provider ?? {})) {
+      const baseUrl = p?.options?.baseURL;
+      if (!baseUrl || (p.npm && p.npm !== "@ai-sdk/openai-compatible")) continue;
+      const models = {};
+      for (const [id, m] of Object.entries(p.models ?? {})) {
+        models[id] = m?.options ?? {};
+      }
+      out[name.toLowerCase()] = { baseUrl: baseUrl.replace(/\/+$/, ""), apiKey: p.options?.apiKey, models };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+async function ollamaModels() {
+  try {
+    const res = await fetch(`${OLLAMA_BASE}/api/tags`, { signal: AbortSignal.timeout(3000) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return (data.models ?? []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+
+export async function listLocalProviders() {
+  const ollama = await ollamaModels();
+  const config = loadOpencodeConfigProviders();
+  return { ollama, config };
+}
+
+async function runOllama(model, prompt) {
+  const res = await fetch(`${OLLAMA_BASE}/v1/chat/completions`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+    }),
+  });
+  if (!res.ok) throw new Error(`Ollama ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content;
+}
+
+export async function runAuthDirect(model, prompt) {
+  const slashIdx = model.indexOf("/");
+  if (slashIdx <= 0) throw new Error(`expected provider/model format, got '${model}'`);
+  const prov = model.slice(0, slashIdx);
+  const id = model.slice(slashIdx + 1);
+  const auth = loadOpencodeAuth();
+  if (!auth[prov]?.key)
+    throw new Error(`no opencode login for '${prov}' — run: opencode auth login ${prov}`);
+  const catalog = await loadCatalog();
+  const info = catalog[prov];
+  if (!info?.api || info.npm !== "@ai-sdk/openai-compatible")
+    throw new Error(`provider '${prov}' is not OpenAI-compatible for direct calls — use 'opencode:${prov}/${id}' instead`);
+  const text = await callDirect(info.api, id, [{ role: "user", content: prompt }], auth[prov].key);
+  return { text, tokens: null, backend: `opencode-auth:${prov}` };
+}
+
+export async function runOne(model, prompt) {
+  if (model.startsWith("opencode:")) {
+    const r = await opencodeRun(model.slice("opencode:".length), prompt);
+    return { text: r.text, tokens: r.tokens, backend: "opencode" };
+  }
+
+  if (model.startsWith("ollama:") || model.startsWith("local:") || model.startsWith("ollama/")) {
+    const id = model.replace(/^(ollama:|local:|ollama\/)/, "");
+    const text = await runOllama(id, prompt);
+    return { text, tokens: null, backend: "ollama" };
+  }
+
+  // provider/model → opencode auth (catalog) or opencode.json custom providers
+  const slashIdx = model.indexOf("/");
+  if (slashIdx > 0) {
+    const prov = model.slice(0, slashIdx).toLowerCase();
+    const id = model.slice(slashIdx + 1);
+    const custom = loadOpencodeConfigProviders()[prov];
+    if (custom) {
+      const extra = custom.models[id] ?? {};
+      const text = await callDirect(custom.baseUrl, id, [{ role: "user", content: prompt }], custom.apiKey, extra);
+      return { text, tokens: null, backend: `config:${prov}` };
+    }
+    return runAuthDirect(model, prompt);
+  }
+
+  throw new Error(`unknown model '${model}' — see list_models`);
+}
+
+export async function gitDiff() {  try {
+    const { stdout } = await execFileAsync("git", ["diff", "HEAD"], {
+      cwd: process.cwd(),
+      maxBuffer: 5 * 1024 * 1024,
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "forge-delegate",
+  "version": "1.0.0",
+  "description": "MCP server that relays coding work to other AI models (DeepSeek, Gemini, OpenAI, Ollama) so Claude Code saves tokens",
+  "type": "module",
+  "bin": {
+    "forge-delegate": "./cli.mjs"
+  },
+  "scripts": {
+    "setup": "node cli.mjs setup",
+    "start": "node cli.mjs serve",
+    "prepublishOnly": "node --check cli.mjs && node --check server.mjs && node --check lib.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "server.mjs",
+    "lib.mjs",
+    "install.sh",
+    "docs/",
+    "README.md"
+  ],
+  "keywords": ["mcp", "claude", "claude-code", "ai", "deepseek", "gemini", "ollama", "delegation"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  }
+}

package/server.mjs

@@ -0,0 +1,260 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, openSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  logUsage,
+  opencodeRun,
+  runOne,
+  gitDiff,
+  opencodeArgs,
+  parseEvents,
+  pickVariant,
+  listAuthDirectProviders,
+  listLocalProviders,
+  loadConfig,
+  saveConfig,
+  configPath,
+  resolveConfig,
+} from "./lib.mjs";
+
+const execFileAsync = promisify(execFile);
+const RUNS_DIR = join(homedir(), ".forge-delegate", "runs");
+
+const INSTRUCTIONS = `forge-delegate gives you a crew of external AI models to delegate coding work to. Hand off the high-volume, low-risk work (boilerplate, tests, lint/type fixes, mechanical edits) to a cheap or free model and keep the expensive agent focused on architecture and judgment calls.
+
+COST POLICY — MANDATORY, NON-NEGOTIABLE:
+The user pays per delegated call on a budget plan. You MUST pick only cheap or free models for EVERY delegation (ask_model, delegate_task, delegate_agent). NEVER pick top-tier, premium, flagship, or frontier models — not even "just this once" or for hard tasks. If a task seems too hard for a cheap model, split it into smaller delegated steps instead of upgrading. Run list_models and prefer free/cheap models (deepseek flash tiers, free opencode models, local ollama).
+
+Routing:
+- Quick one-shot questions → ask_model (direct API, no file access).
+- Multi-file edits/refactors/tests → delegate_task (synchronous) or delegate_agent (background).
+- delegate_agent returns a job id instantly; poll check_delegation for the result.
+- Follow-ups on a delegated area: pass the returned session id as continue_session.
+- Omit model/directory to use the configured defaults (get_delegate_config); change them anytime with set_delegate_config — never reinstall.
+- Never paste large files into your own context for delegation — delegate and let the agent read files itself.
+
+The per-tool descriptions are the authoritative reference.
+`;
+
+const server = new McpServer(
+  { name: "forge-delegate", version: "1.0.0" },
+  { instructions: INSTRUCTIONS }
+);
+
+// Uniform wrapper: times the call, records usage, converts errors to tool errors.
+async function withUsage(tool, model, fn) {
+  const started = Date.now();
+  try {
+    const text = await fn();
+    logUsage({ tool, model, ms: Date.now() - started, ok: true });
+    return { content: [{ type: "text", text }] };
+  } catch (e) {
+    logUsage({ tool, model, ms: Date.now() - started, ok: false });
+    return { content: [{ type: "text", text: `ERROR: ${e.message}` }], isError: true };
+  }
+}
+
+function sessionFooter(sessionId, tokens) {
+  const parts = [];
+  if (tokens) parts.push(`~${tokens} tokens used`);
+  parts.push(`session: ${sessionId}`);
+  return "\n" + parts.join(" · ");
+}
+
+async function startBackgroundJob(model, task, opts = {}) {
+  const variant = await pickVariant(model);
+  mkdirSync(RUNS_DIR, { recursive: true });
+  const id = `job_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  const logPath = join(RUNS_DIR, `${id}.log`);
+  const out = openSync(logPath, "w");
+  const cwd = opts.directory ?? process.cwd();
+  const child = spawn("opencode", opencodeArgs(model, task, { ...opts, variant }), {
+    cwd,
+    detached: true,
+    stdio: ["ignore", out, out],
+  });
+  child.unref();
+  writeFileSync(join(RUNS_DIR, `${id}.json`), JSON.stringify({ id, pid: child.pid, model, directory: cwd, started: Date.now(), logPath }));
+  return id;
+}
+
+server.tool(
+  "list_models",
+  "List models available for delegation: local/keyless ones, fast direct-API models from opencode logins, and agentic models from the local opencode installation.",
+  {},
+  async () =>
+    withUsage("list_models", "-", async () => {
+      const lines = ["== local / keyless (ask_model) =="];
+      const local = await listLocalProviders();
+      if (local.ollama.length) lines.push(`  ollama: ${local.ollama.slice(0, 12).join(", ")}`);
+      else lines.push("  ollama: not running");
+      for (const [name, p] of Object.entries(local.config))
+        lines.push(`  ${name} (opencode.json): ${p.models.join(", ") || "(models defined ad hoc)"}`);
+
+      lines.push("\n== direct via opencode logins (ask_model, provider/model) ==");
+      try {
+        const authed = await listAuthDirectProviders();
+        if (!authed.length) lines.push("  none — run 'opencode auth login <provider>'");
+        for (const p of authed)
+          lines.push(`  ${p.name}: ${p.models.join(", ") || "(model list unavailable — still usable)"}`);
+      } catch (e) {
+        lines.push(`  (unavailable: ${e.message})`);
+      }
+
+      lines.push("\n== agentic via opencode (delegate_* tools) ==");
+      try {
+        const { stdout } = await execFileAsync("opencode", ["models"], { timeout: 15_000, maxBuffer: 1024 * 1024 });
+        lines.push(stdout.trim());
+      } catch {
+        lines.push("opencode not found");
+      }
+
+      return lines.join("\n");
+    })
+);
+
+server.tool(
+  "ask_model",
+  "Send a one-shot prompt to an external AI model and get its raw response. Fast direct API call; the model has NO file access and CANNOT take actions. For work requiring tools/files use delegate_agent instead. model defaults to the configured defaultModel.",
+  {
+    model: z.string().optional().describe("provider/model, e.g. deepseek/deepseek-v4-flash, ollama:llama3 (defaults to config defaultModel)"),
+    prompt: z.string(),
+    system: z.string().optional(),
+  },
+  async ({ model, prompt, system }) => {
+    const r = resolveConfig({ model });
+    if (!r.model) return { content: [{ type: "text", text: "ERROR: no model specified and no defaultModel configured. Call set_delegate_config or pass model." }], isError: true };
+    return withUsage("ask_model", r.model, () =>
+      runOne(r.model, system ? `${system}\n\n---\n\n${prompt}` : prompt).then((x) => x.text)
+    );
+  }
+);
+
+server.tool(
+  "delegate_task",
+  "Delegate a coding task to another AI model running as a full agent (via local opencode): it can read your project and answer with concrete code. Optionally attach specific files. model/directory/agent/autoApprove default from config.",
+  {
+    model: z.string().optional().describe("provider/model format, e.g. opencode/mimo-v2.5-free (defaults to config defaultModel)"),
+    task: z.string(),
+    files: z.array(z.string()).optional(),
+    directory: z.string().optional().describe("absolute path to run in (defaults to config defaultDirectory, else server cwd)"),
+    agent: z.string().optional().describe("opencode agent to use (defaults to config defaultAgent)"),
+    autoApprove: z.boolean().optional().describe("auto-approve permissions (defaults to config autoApprove, true)"),
+    profile: z.string().optional().describe("named config profile to apply"),
+  },
+  async ({ model, task, files, directory, agent, autoApprove, profile }) => {
+    const r = resolveConfig({ model, directory, agent, autoApprove, profile });
+    if (!r.model) return { content: [{ type: "text", text: "ERROR: no model specified and no defaultModel configured. Call set_delegate_config or pass model." }], isError: true };
+    return withUsage("delegate_task", r.model, async () => {
+      const res = await opencodeRun(r.model, task, {
+        files,
+        directory: r.directory,
+        agent: r.agent,
+        autoApprove: r.autoApprove,
+        timeoutMs: r.timeoutMs,
+      });
+      return `${res.text || "(no summary — agent may have only edited files)"}${sessionFooter(res.sessionId, res.tokens)} — pass session id as continue_session to follow up`;
+    });
+  }
+);
+
+server.tool(
+  "delegate_agent",
+  "Fully delegate a coding task to another AI model working autonomously on this project (via local opencode): it explores, reads, edits and creates files in its own loop — invisible to the caller's context. Runs in the BACKGROUND: returns a job id instantly, poll with check_delegation to get the result. Pass continue_session (returned by a previous delegation) to keep the same agent session instead of re-exploring. model/directory/agent/autoApprove default from config.",
+  {
+    model: z.string().optional().describe("provider/model format, e.g. opencode/mimo-v2.5-free (defaults to config defaultModel)"),
+    task: z.string(),
+    continue_session: z.string().optional().describe("session id returned by a previous delegation"),
+    directory: z.string().optional().describe("absolute path to run in (defaults to config defaultDirectory, else server cwd)"),
+    agent: z.string().optional().describe("opencode agent to use (defaults to config defaultAgent)"),
+    autoApprove: z.boolean().optional().describe("auto-approve permissions (defaults to config autoApprove, true)"),
+    profile: z.string().optional().describe("named config profile to apply"),
+  },
+  async ({ model, task, continue_session, directory, agent, autoApprove, profile }) => {
+    const r = resolveConfig({ model, directory, agent, autoApprove, profile });
+    if (!r.model) return { content: [{ type: "text", text: "ERROR: no model specified and no defaultModel configured. Call set_delegate_config or pass model." }], isError: true };
+    return withUsage("delegate_agent", r.model, async () => {
+      const id = await startBackgroundJob(r.model, task, {
+        sessionId: continue_session,
+        directory: r.directory,
+        agent: r.agent,
+        autoApprove: r.autoApprove,
+      });
+      return `Started background job ${id}. Poll with check_delegation(id: "${id}").`;
+    });
+  }
+);
+
+server.tool(
+  "check_delegation",
+  "Check status of a background delegation job: running/completed plus output so far. Call with no id to list all jobs.",
+  { id: z.string().optional() },
+  async ({ id }) =>
+    withUsage("check_delegation", id ?? "-", async () => {
+      if (!existsSync(RUNS_DIR)) return "no jobs yet";
+      if (!id) {
+        const jobs = readdirSync(RUNS_DIR)
+          .filter((f) => f.endsWith(".json"))
+          .map((f) => JSON.parse(readFileSync(join(RUNS_DIR, f), "utf8")))
+          .map((m) => `${m.id} [${m.model}] started ${new Date(m.started).toLocaleTimeString()}`);
+        return jobs.join("\n") || "no jobs yet";
+      }
+      const metaPath = join(RUNS_DIR, `${id}.json`);
+      if (!existsSync(metaPath)) return `unknown job ${id}`;
+      const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+      let running = false;
+      try {
+        process.kill(meta.pid, 0);
+        running = true;
+      } catch {}
+      const log = existsSync(meta.logPath) ? readFileSync(meta.logPath, "utf8") : "";
+      const parsed = parseEvents(log);
+      const tail = parsed.text || "(agent still thinking, no text output yet)";
+      const footer = parsed.sessionId ? ` · session: ${parsed.sessionId}` : "";
+      return `[${running ? "RUNNING" : "DONE"}] ${id} (${meta.model}, ${Math.round((Date.now() - meta.started) / 1000)}s)${footer}\n\n${tail.slice(-8000)}`;
+    })
+);
+
+server.tool(
+  "get_delegate_config",
+  "Read the current forge-delegate configuration: defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, and named profiles. Call this to see what will be used when a model/directory is omitted.",
+  {},
+  async () => {
+    const cfg = loadConfig();
+    const { profiles, ...rest } = cfg;
+    const lines = Object.entries(rest).map(([k, v]) => `  ${k}: ${v ?? "(unset)"}`);
+    const prof = Object.entries(profiles).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n") || "  (none)";
+    return `config: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}`;
+  }
+);
+
+server.tool(
+  "set_delegate_config",
+  "Change forge-delegate configuration at runtime — no reinstall. Pass any subset of {defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, profiles}. Set a field to null to clear it. To edit a profile, pass the whole profiles object (e.g. profiles: {tests: {model: \"...\"}}); set a profile to null to delete it. Only provided keys change; others are preserved.",
+  {
+    defaultModel: z.string().nullable().optional(),
+    defaultAgent: z.string().nullable().optional(),
+    defaultVariant: z.string().nullable().optional(),
+    autoApprove: z.boolean().optional(),
+    timeoutMs: z.number().optional(),
+    defaultDirectory: z.string().nullable().optional(),
+    profiles: z.record(z.any()).optional(),
+  },
+  async (patch) => {
+    try {
+      saveConfig(patch);
+      const cfg = loadConfig();
+      return `Updated. defaultModel=${cfg.defaultModel ?? "(unset)"}, autoApprove=${cfg.autoApprove}, defaultDirectory=${cfg.defaultDirectory ?? "(unset)"}, profiles=${Object.keys(cfg.profiles).join(",") || "none"}`;
+    } catch (e) {
+      return { content: [{ type: "text", text: `ERROR: ${e.message}` }], isError: true };
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);