overseer-mcp 0.1.1

package/dist/prompts.js

@@ -0,0 +1,144 @@
+import { renderSnapshots } from "./repo/files.js";
+const SHARED_RULES = `You are the expert supervising a less capable executor agent.
+Respond in the same language as the task or question.
+Be decisive and brief: output only the requested contract, with no preamble.
+Demand minimal, surgical changes. Forbid scope creep, broad refactors, renames, new dependencies, and global config edits unless explicitly required.
+You receive summaries, file excerpts, and evidence provided by the executor agent. Work with what is given — do not assume access to the full repo.
+If evidence is insufficient, ask for the missing input instead of guessing.
+Preserve existing behavior. Flag regression risk.
+Prohibitions: no broken behavior, no invented APIs/routes/tables, no data deletion, no design changes unless asked.
+Keep the answer self-sufficient so the executor does not spend tokens rereading the whole project.`;
+const NOTES_GROUND_TRUTH_RULE = `EXECUTOR NOTES and FILE SUMMARIES are the executor's own analysis of the codebase. Use them as your primary context to plan the implementation.
+If the summaries are insufficient to plan safely, name the specific files or details you need under RISKS so the executor can provide them — do not invent contents.`;
+export const GET_PLAN_FULL_SYSTEM_PROMPT = `${SHARED_RULES}
+${NOTES_GROUND_TRUTH_RULE}
+
+Return exactly this full planning contract:
+PLAN
+INTERPRETATION: 1-2 lines restating what the user wants; flag ambiguity.
+GOAL: exact functional objective.
+FILES TO TOUCH: path -> what changes, only what is needed.
+DO NOT TOUCH: explicit out-of-scope items and behavior to preserve.
+STEPS: ordered, executable, minimal steps the executor can follow without extra context.
+CONSTRAINTS: project rules and prohibitions.
+SUCCESS CRITERIA: verifiable acceptance checks.
+RISKS: technical risks, edge cases, regressions to watch.
+VALIDATION: manual and automated checks to run if present.
+ESCALATION: always include this line reminding the executor that for any complex or non-trivial problem, unclear error, or ambiguity that comes up while implementing, it must call the consult_expert MCP tool before improvising, bringing the 2+ candidate options/approaches it is weighing so the expert decides among them.
+
+If required input is missing, state it under INTERPRETATION and still give the safest minimal next step.`;
+export const GET_PLAN_LITE_SYSTEM_PROMPT = `${SHARED_RULES}
+${NOTES_GROUND_TRUTH_RULE}
+
+Lite mode: do not analyze every file. Inspect only the minimum context needed to orient the executor.
+Return exactly:
+INTERPRETATION
+FILES/AREAS
+WHAT TO DO
+CONSTRAINTS
+VALIDATION
+ESCALATION: always include this line reminding the executor that for any complex or non-trivial problem, unclear error, or ambiguity that comes up while implementing, it must call the consult_expert MCP tool before improvising, bringing the 2+ candidate options/approaches it is weighing so the expert decides among them.
+
+If required input is missing, name the missing input briefly.`;
+export const CONSULT_EXPERT_SYSTEM_PROMPT = `${SHARED_RULES}
+
+Return exactly this intervention contract:
+INTERVENTION: PROCEED | DECIDE | FIX | REDIRECT | NEED_INFO
+SUMMARY: 1-2 lines with the verdict.
+ACTION: numbered concrete steps.
+WATCH_OUT: up to 2 bullets, only for real regression or edge risk.
+
+Use PROCEED for a correct instinct, DECIDE to choose among options, FIX for root cause and exact fix, REDIRECT for scope or approach correction, and NEED_INFO when missing input prevents a safe answer.
+When OPTIONS CONSIDERED are present, judge each against the real code and pick exactly one decisively (DECIDE), giving a finished answer the executor can act on without further back-and-forth. Reject the discarded options in one line each. Only add an option of your own if every option the executor brought is unsafe.`;
+export const REQUEST_REVIEW_SYSTEM_PROMPT = `${SHARED_RULES}
+
+Judge only the real diff and real validation output. Return exactly:
+REVIEW
+VERDICT: APPROVE | REQUEST_CHANGES
+MATCHES_TASK: yes/no + one line
+REGRESSIONS: list or none
+OUT_OF_SCOPE: list or none
+REQUIRED_FIXES: numbered list only when REQUEST_CHANGES
+
+If validation or diff evidence is missing, mention the missing input and request changes only when it blocks a safe approval.`;
+function renderOutlines(outlines) {
+    return outlines
+        .map((entry) => `----- OUTLINE: ${entry.path} -----\n${entry.outline}`)
+        .join("\n\n");
+}
+export function buildGetPlanUserPayload(input) {
+    const lines = [
+        "TASK",
+        input.task,
+        "",
+        "EXECUTOR NOTES",
+        input.notes?.trim() || "(none)",
+        "",
+        "GIT STATUS",
+        input.gitStatus || "(empty)",
+        "",
+        "REPO MAP (tracked file names only, capped)",
+        input.repoMap || "(empty)",
+    ];
+    if (input.fileSummaries) {
+        lines.push("", "FILE SUMMARIES (provided by executor)", input.fileSummaries);
+    }
+    if (input.snapshots.length > 0) {
+        const filesHeader = input.autoSelected?.length
+            ? `FILES (read from disk; server-selected by relevance: ${input.autoSelected.join(", ")})`
+            : "FILES (read from disk)";
+        lines.push("", filesHeader, renderSnapshots(input.snapshots));
+    }
+    if (input.outlines?.length) {
+        lines.push("", "OUTLINES (signature-only to save tokens; need a body? Name the file under RISKS so the executor opens it.)", renderOutlines(input.outlines));
+    }
+    return lines.join("\n");
+}
+export function buildConsultExpertUserPayload(input) {
+    const lines = [
+        "QUESTION",
+        input.question,
+        "",
+        "OPTIONS CONSIDERED",
+        input.optionsConsidered?.length ? input.optionsConsidered.map((option) => `- ${option}`).join("\n") : "(none)",
+    ];
+    if (input.fileSummaries) {
+        lines.push("", "FILE SUMMARIES (provided by executor)", input.fileSummaries);
+    }
+    if (input.snapshots.length > 0) {
+        lines.push("", "FILES (read from disk)", renderSnapshots(input.snapshots));
+    }
+    if (input.diffSummary) {
+        lines.push("", "DIFF SUMMARY (provided by executor)", input.diffSummary);
+    }
+    if (input.gitDiff) {
+        lines.push("", "DIFF (current unstaged changes from git)", input.gitDiff);
+    }
+    lines.push("", "ERROR OUTPUT", input.errorOutput || "(none)");
+    return lines.join("\n");
+}
+export function buildRequestReviewUserPayload(input) {
+    const lines = [
+        "TASK",
+        input.task || "(not provided)",
+    ];
+    if (input.diffSummary) {
+        lines.push("", "DIFF SUMMARY (provided by executor)", input.diffSummary);
+    }
+    if (input.gitDiff) {
+        lines.push("", "UNSTAGED DIFF", input.gitDiff);
+    }
+    if (input.gitDiffStaged) {
+        lines.push("", "STAGED DIFF", input.gitDiffStaged);
+    }
+    if (input.testOutputSummary) {
+        lines.push("", "TEST OUTPUT SUMMARY (provided by executor)", input.testOutputSummary);
+    }
+    if (input.testOutput) {
+        lines.push("", "TEST OUTPUT", input.testOutput);
+    }
+    return lines.join("\n");
+}
+export function renderTestResult(result) {
+    return [`COMMAND: ${result.command}`, `EXIT_CODE: ${result.exitCode}`, "OUTPUT", result.output || "(empty)"].join("\n");
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,50 @@
+/**
+ * Talks to the Anthropic Messages API directly via native fetch.
+ */
+export class AnthropicProvider {
+    cfg;
+    id;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.id = `anthropic:${cfg.model}`;
+    }
+    async complete(req) {
+        const base = (this.cfg.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
+        const res = await fetch(`${base}/v1/messages`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": this.cfg.apiKey,
+                "anthropic-version": "2023-06-01",
+                "anthropic-beta": "prompt-caching-2024-07-31",
+            },
+            body: JSON.stringify({
+                model: this.cfg.model,
+                max_tokens: this.cfg.maxTokens ?? req.maxTokens ?? 4096,
+                temperature: this.cfg.temperature ?? req.temperature ?? 0.2,
+                system: [
+                    {
+                        type: "text",
+                        text: req.system,
+                        cache_control: { type: "ephemeral" },
+                    },
+                ],
+                messages: [{ role: "user", content: req.user }],
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`Anthropic API error ${res.status}: ${body.slice(0, 500)}`);
+        }
+        const data = (await res.json());
+        const text = (data.content ?? [])
+            .filter((b) => b.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("\n")
+            .trim();
+        if (text.length === 0) {
+            throw new Error("Anthropic provider returned an empty completion");
+        }
+        return text;
+    }
+}

package/dist/providers/cli.js

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+/**
+ * Uses a coding-plan CLI (Codex, Claude Code, ...) as the expert by invoking
+ * it as a subprocess. For users who pay via a coding plan and have no API key.
+ *
+ * The command is fully configurable because each CLI has its own one-shot
+ * invocation. Combine system + user into a single prompt and stream it in.
+ */
+export class CliProvider {
+    cfg;
+    id;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.id = `cli:${cfg.command}`;
+    }
+    async complete(req) {
+        const prompt = `${req.system}\n\n========\n\n${req.user}`;
+        const args = this.cfg.promptVia === "arg" ? [...this.cfg.args, prompt] : [...this.cfg.args];
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.cfg.command, args, { cwd: this.cfg.cwd, shell: process.platform === "win32" });
+            let stdout = "";
+            let stderr = "";
+            const timer = setTimeout(() => {
+                child.kill("SIGKILL");
+                reject(new Error(`CLI provider "${this.cfg.command}" timed out after ${this.cfg.timeoutMs}ms`));
+            }, this.cfg.timeoutMs);
+            child.stdout.on("data", (d) => (stdout += d.toString()));
+            child.stderr.on("data", (d) => (stderr += d.toString()));
+            child.on("error", (err) => {
+                clearTimeout(timer);
+                reject(new Error(`Failed to launch CLI provider "${this.cfg.command}": ${err.message}`));
+            });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                if (code !== 0) {
+                    reject(new Error(`CLI provider exited with code ${code}: ${stderr.slice(0, 500)}`));
+                    return;
+                }
+                const text = stdout.trim();
+                if (text.length === 0) {
+                    reject(new Error("CLI provider returned empty output"));
+                    return;
+                }
+                resolve(text);
+            });
+            if (this.cfg.promptVia === "stdin") {
+                child.stdin.write(prompt);
+                child.stdin.end();
+            }
+        });
+    }
+}

package/dist/providers/openaiCompatible.js

@@ -0,0 +1,42 @@
+/**
+ * Works with any endpoint that speaks the OpenAI Chat Completions shape:
+ * OpenAI, GLM (Zhipu), opencode-compatible gateways, local servers, etc.
+ * Uses native fetch — no SDK dependency.
+ */
+export class OpenAICompatibleProvider {
+    cfg;
+    id;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.id = `openai-compatible:${cfg.model}`;
+    }
+    async complete(req) {
+        const url = `${this.cfg.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${this.cfg.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.cfg.model,
+                temperature: this.cfg.temperature ?? req.temperature ?? 0.2,
+                max_tokens: this.cfg.maxTokens ?? req.maxTokens,
+                messages: [
+                    { role: "system", content: req.system },
+                    { role: "user", content: req.user },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`OpenAI-compatible API error ${res.status}: ${body.slice(0, 500)}`);
+        }
+        const data = (await res.json());
+        const text = data.choices?.[0]?.message?.content;
+        if (typeof text !== "string" || text.length === 0) {
+            throw new Error("OpenAI-compatible provider returned an empty completion");
+        }
+        return text;
+    }
+}

package/dist/providers/types.js

@@ -0,0 +1,12 @@
+/**
+ * The expert backend abstraction.
+ *
+ * overseer-mcp does not talk to "GPT" or "Claude" directly. It talks to an
+ * ExpertProvider. Anything that can take a system+user prompt and return text
+ * can be the expert: an OpenAI-compatible API (OpenAI, GLM, opencode, ...),
+ * the Anthropic API, or a coding-plan CLI invoked as a subprocess.
+ *
+ * This is what makes overseer portable: clone it, point it at your own
+ * plan/key, and it works with your expert of choice.
+ */
+export {};

package/dist/repo/files.js

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Reads files from disk, scoped to the repo root.
+ *
+ * This is the heart of the anti-bias design: the executor agent says WHICH
+ * files matter, but the CONTENT comes from disk here — never from the
+ * executor's description. The executor cannot misrepresent what a file says.
+ */
+export async function readFiles(repoRoot, filePaths, maxBytes) {
+    const root = path.resolve(repoRoot);
+    return Promise.all(filePaths.map(async (rel) => {
+        const abs = path.resolve(root, rel);
+        // Refuse to escape the repo root.
+        const within = abs === root || abs.startsWith(root + path.sep);
+        if (!within) {
+            return { path: rel, error: "refused: path is outside the repo root" };
+        }
+        try {
+            const raw = await readFile(abs);
+            if (raw.byteLength > maxBytes) {
+                const head = raw.subarray(0, maxBytes).toString("utf8");
+                return {
+                    path: rel,
+                    content: `${head}\n... (truncated at ${maxBytes} bytes; file is ${raw.byteLength} bytes)`,
+                };
+            }
+            return { path: rel, content: raw.toString("utf8") };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { path: rel, error: message };
+        }
+    }));
+}
+/** Render snapshots as a labelled block for the expert prompt. */
+export function renderSnapshots(snapshots) {
+    if (snapshots.length === 0)
+        return "(no files provided)";
+    return snapshots
+        .map((s) => {
+        const header = `----- FILE: ${s.path} -----`;
+        const body = s.error ? `(could not read: ${s.error})` : s.content ?? "";
+        return `${header}\n${body}`;
+    })
+        .join("\n\n");
+}

package/dist/repo/findRoot.js

@@ -0,0 +1,19 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+/**
+ * Walk up from `start` looking for a `.git` entry. Returns the first directory
+ * that contains one, or `undefined` if none is found before hitting the root.
+ */
+export function findGitRoot(start) {
+    let dir = path.resolve(start);
+    // Guard against infinite loops on Windows drive roots.
+    let prev = "";
+    while (dir !== prev) {
+        if (existsSync(path.join(dir, ".git"))) {
+            return dir;
+        }
+        prev = dir;
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}

package/dist/repo/git.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const pexec = promisify(execFile);
+const MAX_BUFFER = 16 * 1024 * 1024; // 16 MB
+async function git(cwd, args) {
+    try {
+        const { stdout } = await pexec("git", args, { cwd, maxBuffer: MAX_BUFFER });
+        return stdout;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return `(git ${args.join(" ")} failed: ${message})`;
+    }
+}
+/** Unstaged changes. The single source of truth for "what the executor did". */
+export function gitDiff(cwd) {
+    return git(cwd, ["diff"]);
+}
+/** Staged changes. */
+export function gitDiffStaged(cwd) {
+    return git(cwd, ["diff", "--staged"]);
+}
+/** Porcelain status — which files changed, added, deleted. */
+export function gitStatus(cwd) {
+    return git(cwd, ["status", "--short", "--branch"]);
+}
+/**
+ * Tracked files as an array, respecting .gitignore. Capped at `limit` entries.
+ * Used both for the planning repo map and for server-side relevance selection.
+ */
+export async function gitTrackedFileList(cwd, limit) {
+    const out = await git(cwd, ["ls-files"]);
+    const lines = out.split("\n").filter(Boolean);
+    return lines.slice(0, limit);
+}
+/**
+ * Tracked files, respecting .gitignore. Used to give the expert an accurate
+ * map of the repo when planning, without reading every byte.
+ */
+export async function gitTrackedFiles(cwd, limit) {
+    const out = await git(cwd, ["ls-files"]);
+    const lines = out.split("\n").filter(Boolean);
+    if (lines.length <= limit)
+        return lines.join("\n");
+    return [...lines.slice(0, limit), `... (${lines.length - limit} more files omitted)`].join("\n");
+}
+/**
+ * Files whose tracked content matches any of `terms` (case-insensitive, literal).
+ * Returns relative paths. Empty/failed search yields an empty list — callers fall
+ * back to path-based relevance so planning still works without grep results.
+ */
+export async function gitGrepFiles(cwd, terms) {
+    if (terms.length === 0)
+        return [];
+    const args = ["grep", "-l", "-i", "-I", "-F"];
+    for (const term of terms) {
+        args.push("-e", term);
+    }
+    const out = await git(cwd, args);
+    if (out.startsWith("(git "))
+        return []; // git() error sentinel (e.g. no matches → exit 1)
+    return out.split("\n").filter(Boolean);
+}

package/dist/repo/retrieve.js

@@ -0,0 +1,118 @@
+import { gitGrepFiles } from "./git.js";
+/**
+ * Server-side relevance selection.
+ *
+ * The expert plans over the REAL repo (PLAN.md goal). But the executor often
+ * cannot name the right `focus_paths` at planning time — that is precisely why
+ * it is asking for a plan. So the server picks likely-relevant files itself,
+ * from disk + git, and feeds their real content to the expert. The executor's
+ * `notes` only steer this ranking; they never replace ground truth.
+ */
+const STOPWORDS = new Set([
+    // English
+    "the", "and", "for", "with", "that", "this", "from", "into", "your", "you", "are",
+    "but", "not", "all", "any", "can", "use", "using", "add", "fix", "make", "should",
+    "when", "what", "which", "how", "why", "need", "want", "please", "code", "file",
+    "files", "function", "change", "changes", "update", "implement", "create",
+    // Spanish
+    "que", "los", "las", "una", "uno", "del", "con", "por", "para", "como", "esta",
+    "este", "esto", "pero", "más", "mas", "hacer", "hace", "tiene", "sea", "ser",
+    "agregar", "cambiar", "arreglar", "necesito", "quiero", "archivo", "archivos",
+    "función", "funcion", "código", "codigo",
+]);
+/** Tokenize free text into significant lowercase terms for matching. */
+export function extractTerms(text, max = 12) {
+    const seen = new Set();
+    const terms = [];
+    const tokens = text
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/i)
+        .filter(Boolean);
+    for (const token of tokens) {
+        if (token.length < 3)
+            continue;
+        if (STOPWORDS.has(token))
+            continue;
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        terms.push(token);
+        if (terms.length >= max)
+            break;
+    }
+    return terms;
+}
+/** Lockfiles and similar generated files that never help the expert plan. */
+const NOISE_BASENAMES = new Set([
+    "package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "pnpm-lock.yaml",
+    "poetry.lock", "Cargo.lock", "composer.lock", "Gemfile.lock", "go.sum",
+]);
+/**
+ * Generated/non-source artifacts that add tokens without helping the expert
+ * plan: anything inside a dot-directory (.agent-results/, .claude/, .qoder/,
+ * .github/, ...), lockfiles, sourcemaps and minified bundles. Only applied to
+ * the server's own auto-selection — files the executor names in focus_paths are
+ * always respected.
+ */
+function isNoisePath(file) {
+    const norm = file.replace(/\\/g, "/");
+    if (/(^|\/)\.[^/]+\//.test(norm))
+        return true;
+    const base = norm.slice(norm.lastIndexOf("/") + 1);
+    if (NOISE_BASENAMES.has(base))
+        return true;
+    if (/\.(min\.js|map)$/.test(base))
+        return true;
+    return false;
+}
+/**
+ * Rank tracked files by relevance to `terms` and return up to `limit` paths,
+ * excluding anything in `exclude`. Combines a content match (git grep) with a
+ * path/name match, so a file is surfaced whether the terms appear in its code
+ * or in its path. Falls back to path scoring alone if grep yields nothing.
+ */
+export async function selectRelevantFiles(repoRoot, tracked, terms, exclude, limit) {
+    if (limit <= 0 || terms.length === 0 || tracked.length === 0)
+        return [];
+    const contentHits = new Set(await gitGrepFiles(repoRoot, terms));
+    const scored = [];
+    for (const file of tracked) {
+        if (exclude.has(file))
+            continue;
+        if (isNoisePath(file))
+            continue;
+        const lower = file.toLowerCase();
+        let score = 0;
+        if (contentHits.has(file))
+            score += 3;
+        for (const term of terms) {
+            if (lower.includes(term))
+                score += 2;
+        }
+        if (score === 0)
+            continue;
+        scored.push({ path: file, score });
+    }
+    scored.sort((a, b) => b.score - a.score || a.path.length - b.path.length);
+    return scored.slice(0, limit).map((entry) => entry.path);
+}
+/** Declaration-shaped lines across common languages (JS/TS, Python, Go, etc.). */
+const DECLARATION_RE = /^\s*(export\s+)?(default\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def|func|public|private|protected|static|module|namespace|struct|impl|fn)\b/;
+/**
+ * Cheap structural skim of a file: keeps only declaration-shaped lines with their
+ * line numbers, so the expert sees a file's shape (functions, classes, exports)
+ * without paying for the full body. Used for likely-relevant files that are not
+ * in the top tier that gets full content.
+ */
+export function outlineFile(content, maxLines = 60) {
+    const lines = content.split("\n");
+    const picked = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (DECLARATION_RE.test(lines[i])) {
+            picked.push(`${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+            if (picked.length >= maxLines)
+                break;
+        }
+    }
+    return picked.length > 0 ? picked.join("\n") : "(no declarations detected)";
+}

package/dist/repo/tests.js

@@ -0,0 +1,21 @@
+import { exec } from "node:child_process";
+const MAX_BUFFER = 16 * 1024 * 1024; // 16 MB
+/**
+ * Runs the configured validation command (typecheck/lint/test/build) so the
+ * reviewer judges real output, not the executor's claim that "tests pass".
+ *
+ * Opt-in: only runs when OVERSEER_TEST_COMMAND is configured.
+ */
+export function runTests(cwd, command, timeoutMs) {
+    return new Promise((resolve) => {
+        exec(command, { cwd, timeout: timeoutMs, maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
+            const output = `${stdout}\n${stderr}`.trim();
+            const exitCode = err && typeof err.code === "number"
+                ? err.code
+                : err
+                    ? 1
+                    : 0;
+            resolve({ command, exitCode, output });
+        });
+    });
+}

package/dist/tools/consultExpert.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { withRepoRoot } from "../config.js";
+import { buildConsultExpertUserPayload, CONSULT_EXPERT_SYSTEM_PROMPT } from "../prompts.js";
+import { gitDiff } from "../repo/git.js";
+import { CONSULT_MAX_TOKENS, errorResult, readCappedFiles, TEMPERATURE, textResult } from "./shared.js";
+export const consultExpertInputSchema = {
+    question: z.string().min(1).describe("What the executor needs decided. State the problem and, whenever there is more than one reasonable approach, the candidate options you are weighing."),
+    file_summaries: z.string().optional().describe("Executor-provided summaries of relevant file content. When provided, the server skips reading files from disk and forwards these summaries to the expert."),
+    diff_summary: z.string().optional().describe("Executor-provided summary of current changes. When provided, the server skips running git diff."),
+    file_paths: z.array(z.string()).optional().describe("Relevant files; the server reads them from disk. Ignored when file_summaries is provided."),
+    repo_root: z.string().optional().describe("Absolute path to the project root. Overrides the server default."),
+    error_output: z.string().optional().describe("Literal error or test output, if any."),
+    options_considered: z.array(z.string()).optional().describe("The candidate solutions/approaches you are weighing. Bring 2+ whenever the problem has more than one reasonable path, so the expert picks one decisively instead of inventing an approach from scratch."),
+};
+export async function handleConsultExpert(input, config) {
+    try {
+        const effective = input.repo_root ? withRepoRoot(config, input.repo_root) : config;
+        const snapshots = input.file_summaries
+            ? []
+            : await readCappedFiles(effective, input.file_paths);
+        const diff = input.diff_summary
+            ? ""
+            : await gitDiff(effective.repoRoot);
+        const user = buildConsultExpertUserPayload({
+            question: input.question,
+            snapshots,
+            gitDiff: diff,
+            errorOutput: input.error_output,
+            optionsConsidered: input.options_considered,
+            fileSummaries: input.file_summaries,
+            diffSummary: input.diff_summary,
+        });
+        const text = await effective.provider.complete({
+            system: CONSULT_EXPERT_SYSTEM_PROMPT,
+            user,
+            maxTokens: CONSULT_MAX_TOKENS,
+            temperature: TEMPERATURE,
+        });
+        return textResult(text);
+    }
+    catch (err) {
+        return errorResult("consult_expert", err);
+    }
+}