github-router 0.3.29 → 0.3.31

package/dist/main.js

@@ -4874,6 +4874,35 @@ function geminiAvailable() {
 	return models.some((m) => /^gemini-3\..*pro/i.test(m.id));
 }
 /**
+* Gate for the `stand_in` tool.
+*
+* Returns true iff Copilot's live catalog (`state.models?.data`) contains
+* ALL THREE peer models the consensus protocol needs:
+*   - `gpt-5.5`             (codex_critic's model)
+*   - `claude-opus-4-7`     (opus_critic's model)
+*   - any `gemini-3.X.*pro` (gemini_critic's model family — matches the
+*     same regex `geminiAvailable()` uses, so the gate stays in sync if
+*     the GA slug renames `gemini-3.1-pro-preview` → `gemini-3.1-pro`)
+*
+* If any one is missing, `stand_in` is dropped from `tools/list` AND
+* fails `tools/call` with -32601 (mirroring the `worker` capability's
+* defense-in-depth pattern — the gated tool is functionally invisible).
+*
+* Tier-mismatch on `claude-opus-4-7`: the proxy's `resolveModel` will
+* fuzzy-match `claude-opus-4-7` to `claude-opus-4.7` (Copilot's dotted
+* slug). For the catalog probe we use the Anthropic-published dashed
+* slug too — `state.models?.data` mirrors Copilot's catalog where these
+* land under the dotted slug, so we match by Copilot's actual id shape.
+*/
+function standInToolEnabled() {
+	const models = state.models?.data;
+	if (!models) return false;
+	const hasGpt55 = models.some((m) => m.id === "gpt-5.5");
+	const hasOpus = models.some((m) => m.id === "claude-opus-4-7" || m.id === "claude-opus-4.7");
+	const hasGeminiPro = models.some((m) => /^gemini-3\..*pro/i.test(m.id));
+	return hasGpt55 && hasOpus && hasGeminiPro;
+}
+/**
 * Gate for the worker tools (`worker_explore`, `worker_implement`).
 *
 * Returns true iff BOTH:
@@ -4934,7 +4963,11 @@ function toolEntries() {
 			}
 		}
 	}));
-	const nonPersonaEntries = NON_PERSONA_MCP_TOOLS.filter((t) => t.capability !== "worker" || workerToolsEnabled()).map((t) => ({
+	const nonPersonaEntries = NON_PERSONA_MCP_TOOLS.filter((t) => {
+		if (t.capability === "worker") return workerToolsEnabled();
+		if (t.capability === "stand_in") return standInToolEnabled();
+		return true;
+	}).map((t) => ({
 		name: t.toolNameHttp,
 		description: t.description,
 		inputSchema: t.inputSchema
@@ -5054,10 +5087,21 @@ function jsonPathPreflightCap(body) {
 	const params = body.params ?? {};
 	const name$1 = typeof params.name === "string" ? params.name : "";
 	const args = params.arguments ?? {};
+	if (!name$1) return void 0;
+	if (name$1 === "stand_in") {
+		const decision = typeof args.decision === "string" ? args.decision : "";
+		const optionsRaw = Array.isArray(args.options) ? args.options : [];
+		const standInContext = typeof args.context === "string" ? args.context : "";
+		if (!decision || optionsRaw.length === 0) return void 0;
+		const briefBytes$1 = Buffer.byteLength(decision + JSON.stringify(optionsRaw) + standInContext, "utf8");
+		const STAND_IN_CAP_BYTES = 6 * 1024;
+		if (briefBytes$1 > STAND_IN_CAP_BYTES) return rpcResult(body.id, toolError(`pre-flight rejected: stand_in on a ${briefBytes$1}-byte input is predicted to exceed the JSON tools/call timeout (cap=${STAND_IN_CAP_BYTES} bytes). stand_in runs two sequential voting rounds across three frontier models — wall-clock is typically 2-3 minutes regardless of input size. Send Accept: text/event-stream to use the SSE path which bypasses this cap, or trim the decision/options/context.`));
+		return;
+	}
 	const prompt = typeof args.prompt === "string" ? args.prompt : "";
 	const context = typeof args.context === "string" ? args.context : void 0;
 	const rawEffort = args.effort;
-	if (!name$1 || !prompt) return void 0;
+	if (!prompt) return void 0;
 	const persona = activePersonas().find((p) => p.toolNameHttp === name$1);
 	if (!persona) return void 0;
 	if (rawEffort !== void 0 && !isEffort(rawEffort)) return void 0;
@@ -5069,60 +5113,81 @@ function jsonPathPreflightCap(body) {
 	if (!verdict.tooLong) return void 0;
 	return rpcResult(body.id, toolError(`pre-flight rejected: ${persona.toolNameHttp} at effort=${effort} on a ${briefBytes}-byte brief is empirically predicted to exceed the JSON tools/call timeout (cap=${verdict.capBytes} bytes for this tier). Either drop to a lower effort tier, split the brief into 2-4 parallel sub-calls per the decomposition guidance, or send Accept: text/event-stream to use the SSE path which bypasses this cap.`));
 }
-async function callPersona(persona, prompt, context, effort, signal) {
-	const resolvedModel = resolveModel(persona.model);
-	const userText = buildUserText(prompt, context);
-	if (persona.endpoint === "/v1/responses") {
-		const text$1 = extractResponsesText(await createResponses({
-			model: resolvedModel,
-			instructions: persona.baseInstructions,
-			input: [{
-				role: "user",
-				content: [{
-					type: "input_text",
-					text: userText
-				}]
-			}],
-			stream: false,
-			reasoning: { effort }
-		}, void 0, signal));
-		if (!text$1) return toolError(`persona ${persona.agentName}: empty assistant output`);
-		return { content: [{
-			type: "text",
-			text: text$1
-		}] };
-	}
-	if (persona.endpoint === "/v1/messages") {
-		const maxTokens = effort === "low" ? 4096 : effort === "medium" ? 8192 : effort === "high" ? 16384 : 32768;
-		const text$1 = extractMessagesText(await (await createMessages(JSON.stringify({
+/**
+* Per-endpoint wire dispatch for a single peer-model call. Returns the
+* assistant's raw text (possibly empty — caller decides what "empty"
+* means in their context). Upstream errors (network, 4xx, 5xx) propagate
+* as exceptions via `await`.
+*
+* Extracted from `callPersona()` so non-persona callers — specifically
+* the `stand_in` orchestrator in `src/lib/stand-in.ts` — can reuse the
+* same per-endpoint request shaping without re-implementing it. The
+* stand_in tool needs to drive its own per-round system prompts across
+* three concrete models (gpt-5.5, claude-opus-4-7, gemini-3.1-pro-preview),
+* each on a different endpoint; doing that with a `PersonaSpec` would
+* require either inventing throwaway personas per round or duplicating
+* the dispatch switch.
+*
+* NOTE on consumer-cancel signal: we deliberately do NOT pass
+* c.req.raw.signal into the upstream fetch. Bun/srvx aborts the
+* request signal as soon as the request body is fully consumed
+* (after `await c.req.json()`), which would make every call fail
+* immediately with "This operation was aborted". The caller creates
+* its own AbortController and threads it through `signal`. See CLAUDE.md
+* "Bun request-signal quirk" for full context.
+*/
+async function dispatchModelCall(args) {
+	const resolvedModel = resolveModel(args.model);
+	if (args.endpoint === "/v1/responses") return extractResponsesText(await createResponses({
+		model: resolvedModel,
+		instructions: args.instructions,
+		input: [{
+			role: "user",
+			content: [{
+				type: "input_text",
+				text: args.userText
+			}]
+		}],
+		stream: false,
+		reasoning: { effort: args.effort }
+	}, void 0, args.signal));
+	if (args.endpoint === "/v1/messages") {
+		const maxTokens = args.effort === "low" ? 4096 : args.effort === "medium" ? 8192 : args.effort === "high" ? 16384 : 32768;
+		return extractMessagesText(await (await createMessages(JSON.stringify({
 			model: resolvedModel,
 			max_tokens: maxTokens,
-			system: persona.baseInstructions,
+			system: args.instructions,
 			thinking: { type: "adaptive" },
-			output_config: { effort },
+			output_config: { effort: args.effort },
 			messages: [{
 				role: "user",
-				content: userText
+				content: args.userText
 			}]
-		}), void 0, signal)).json());
-		if (!text$1) return toolError(`persona ${persona.agentName}: empty assistant output`);
-		return { content: [{
-			type: "text",
-			text: text$1
-		}] };
+		}), void 0, args.signal)).json());
 	}
-	const text = extractChatCompletionText(await createChatCompletions({
+	return extractChatCompletionText(await createChatCompletions({
 		model: resolvedModel,
 		messages: [{
 			role: "system",
-			content: persona.baseInstructions
+			content: args.instructions
 		}, {
 			role: "user",
-			content: userText
+			content: args.userText
 		}],
 		stream: false,
-		reasoning_effort: effort
-	}, void 0, signal));
+		reasoning_effort: args.effort
+	}, void 0, args.signal));
+}
+async function callPersona(persona, prompt, context, effort, signal) {
+	const userText = buildUserText(prompt, context);
+	const text = await dispatchModelCall({
+		model: persona.model,
+		endpoint: persona.endpoint,
+		instructions: persona.baseInstructions,
+		userText,
+		effort,
+		signal
+	});
 	if (!text) return toolError(`persona ${persona.agentName}: empty assistant output`);
 	return { content: [{
 		type: "text",
@@ -5130,6 +5195,7 @@ async function callPersona(persona, prompt, context, effort, signal) {
 	}] };
 }
 function logTelemetry(t) {
+	if (process.env.GH_ROUTER_LOG_PEER_MCP !== "1") return;
 	const parts = [
 		`[peer-mcp]`,
 		`name=${t.name}`,
@@ -5149,6 +5215,7 @@ async function handleToolsCall(body) {
 	const nonPersonaTool = persona ? void 0 : NON_PERSONA_MCP_TOOLS.find((t) => t.toolNameHttp === name$1);
 	if (!persona && !nonPersonaTool) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "worker" && !workerToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "stand_in" && !standInToolEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	let personaPrompt;
 	let personaContext;
 	let personaEffort;
@@ -7979,6 +8046,341 @@ async function runWorkerAgent(opts) {
 	}
 }
 
+//#endregion
+//#region src/lib/stand-in.ts
+/**
+* The three frontier peers. Effort is FIXED per model — not caller-tunable.
+* The tool's purpose is "give me the best 3-lab judgment available";
+* exposing effort knobs would invite the caller to cheap out and would
+* muddy the consensus signal.
+*
+* gemini-3.1-pro-preview is pinned to `high` because the model rejects
+* `xhigh` at the wire with a Copilot 400. `high` is the realistic ceiling.
+*/
+const STAND_IN_MODELS = Object.freeze([
+	{
+		key: "gpt-5.5",
+		model: "gpt-5.5",
+		endpoint: "/v1/responses",
+		effort: "xhigh"
+	},
+	{
+		key: "claude-opus-4-7",
+		model: "claude-opus-4-7",
+		endpoint: "/v1/messages",
+		effort: "xhigh"
+	},
+	{
+		key: "gemini-3.1-pro-preview",
+		model: "gemini-3.1-pro-preview",
+		endpoint: "/v1/chat/completions",
+		effort: "high"
+	}
+]);
+const SYSTEM_PROMPT_R1 = `You are one of three frontier reasoning models the user has authorized to stand in for them on a bounded decision while they are unavailable. Your task: pick the best option from those provided.
+
+Respond with ONLY a single JSON object — no prose, no markdown fences, no preamble. Schema:
+
+{
+  "choice": "<option.id>" | null,
+  "confidence": <number between 0.0 and 1.0>,
+  "reasoning": "<one short sentence>",
+  "need_more_info": "<what context is missing, if you cannot decide>"
+}
+
+Calibration rules:
+- "confidence" reflects how sure you are this is the better option (not how confident you are in your prose). 0.5 = coin flip. 0.9 = clear winner. Be honestly calibrated; the orchestrator weighs your number directly.
+- If the question is genuinely under-specified — you'd need information you don't have to choose well — set "choice": null AND populate "need_more_info" with the specific gap. Do NOT guess.
+- One sentence of reasoning. Not a paragraph.
+- The other two models will vote independently and you will see their votes in round 2. There is no benefit to anticipating what they'll pick; vote on the merits.
+
+Output ONLY the JSON object. No preamble, no markdown fences, no closing remarks.`;
+const SYSTEM_PROMPT_R2 = `You are one of three frontier reasoning models standing in for the user on a bounded decision. Round 1 voting is complete; you will now see the other models' votes and reasoning. Reconsider with their input visible.
+
+Same JSON schema as round 1:
+
+{
+  "choice": "<option.id>" | null,
+  "confidence": <number between 0.0 and 1.0>,
+  "reasoning": "<one short sentence>",
+  "need_more_info": "<gap, if any>"
+}
+
+Calibration rules:
+- You may keep your round-1 vote OR change it. Do NOT change just to agree — agreement is not the goal, the right answer is. Capitulating to peer pressure when you still believe your original choice is better is a failure mode, not a success.
+- If a peer's reasoning identifies a consideration you missed or weighed wrong, update freely. The blind round was the anti-anchor mechanism; this round is where genuine evidence can move you.
+- If round 1 left you genuinely uncertain and peer reasoning hasn't resolved it, "choice": null is still the honest answer.
+
+Output ONLY the JSON object.`;
+const RETRY_PROMPT_SUFFIX = `\n\nYour previous response was not valid JSON matching the schema. Respond with ONLY the JSON object — no preamble, no markdown fences, no closing remarks. Schema reminder: {"choice": "<id>" | null, "confidence": 0.0-1.0, "reasoning": "<one sentence>", "need_more_info": "<gap, if any>"}`;
+/**
+* Run the two-round stand-in protocol. Returns a structured verdict
+* envelope. Throws only on systemic failure (e.g., all three upstream
+* calls failed) — model-level errors and parse failures are surfaced as
+* `VoteFailure` entries in the result.
+*/
+async function runStandIn(input, signal) {
+	const r1UserText = buildRound1UserText(input);
+	const r1 = await Promise.all(STAND_IN_MODELS.map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R1, r1UserText, signal)));
+	const successfulR1 = r1.filter((r) => isVote(r.vote));
+	if (successfulR1.length === STAND_IN_MODELS.length && successfulR1.every((r) => r.vote.needMoreInfo && r.vote.choice === null)) {
+		const gaps = successfulR1.map((r) => `- ${r.key}: ${r.vote.needMoreInfo}`).join("\n");
+		return {
+			verdict: "need_more_info",
+			recommendation: null,
+			confidence: 0,
+			votes: voteRecord(r1, null),
+			notes: `All three models reported they need more context to decide:\n${gaps}`
+		};
+	}
+	const r1Decision = aggregateVotes(successfulR1);
+	if (r1Decision.verdict === "consensus" && r1Decision.meanConfidence >= .8) return {
+		verdict: "consensus",
+		recommendation: r1Decision.winner,
+		confidence: round2(r1Decision.meanConfidence),
+		votes: voteRecord(r1, null),
+		notes: `All three models picked ${r1Decision.winner} in round 1 with high confidence (skipped round 2).`
+	};
+	if (successfulR1.length < 2) return {
+		verdict: "no_consensus",
+		recommendation: null,
+		confidence: 0,
+		votes: voteRecord(r1, null),
+		notes: `Only ${successfulR1.length} of 3 models returned a parseable round-1 vote; insufficient signal to run round 2.`
+	};
+	const r2UserTextBase = buildRound2UserTextBase(input, r1);
+	const r2 = await Promise.all(STAND_IN_MODELS.map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R2, r2UserTextBase + `\n\nYou are ${cfg.key}. Reconsider and vote.`, signal)));
+	const successfulR2 = r2.filter((r) => isVote(r.vote));
+	if (successfulR2.length < 2) return {
+		verdict: "no_consensus",
+		recommendation: null,
+		confidence: 0,
+		votes: voteRecord(r1, r2),
+		notes: `Only ${successfulR2.length} of 3 models returned a parseable round-2 vote; deferring to user.`
+	};
+	const r2Decision = aggregateVotes(successfulR2);
+	if (r2Decision.verdict === "consensus") return {
+		verdict: "consensus",
+		recommendation: r2Decision.winner,
+		confidence: round2(r2Decision.meanConfidence),
+		votes: voteRecord(r1, r2),
+		notes: `All three models picked ${r2Decision.winner} in round 2.`
+	};
+	if (r2Decision.verdict === "majority") {
+		const dissenters = successfulR2.filter((r) => r.vote.choice !== r2Decision.winner).map((r) => `${r.key} picked ${r.vote.choice ?? "abstain"} (${r.vote.reasoning})`).join("; ");
+		return {
+			verdict: "majority",
+			recommendation: r2Decision.winner,
+			confidence: round2(r2Decision.meanConfidence),
+			votes: voteRecord(r1, r2),
+			notes: `Majority (2 of 3) picked ${r2Decision.winner}. Dissent: ${dissenters}.`
+		};
+	}
+	return {
+		verdict: "no_consensus",
+		recommendation: null,
+		confidence: 0,
+		votes: voteRecord(r1, r2),
+		notes: `Models did not converge in round 2 (votes split). Defer to user.`
+	};
+}
+async function callAndParse(cfg, instructions, userText, signal) {
+	let raw;
+	try {
+		raw = await dispatchModelCall({
+			model: cfg.model,
+			endpoint: cfg.endpoint,
+			instructions,
+			userText,
+			effort: cfg.effort,
+			signal
+		});
+	} catch (err) {
+		return {
+			key: cfg.key,
+			vote: {
+				error: "upstream_error",
+				message: String(err)
+			}
+		};
+	}
+	const first = tryParseVote(raw);
+	if (first.ok) return {
+		key: cfg.key,
+		vote: first.vote
+	};
+	let retryRaw;
+	try {
+		retryRaw = await dispatchModelCall({
+			model: cfg.model,
+			endpoint: cfg.endpoint,
+			instructions,
+			userText: userText + RETRY_PROMPT_SUFFIX,
+			effort: cfg.effort,
+			signal
+		});
+	} catch (err) {
+		return {
+			key: cfg.key,
+			vote: {
+				error: "upstream_error",
+				message: `retry after parse failure: ${String(err)}`
+			}
+		};
+	}
+	const second = tryParseVote(retryRaw);
+	if (second.ok) return {
+		key: cfg.key,
+		vote: second.vote
+	};
+	return {
+		key: cfg.key,
+		vote: {
+			error: "parse_failure",
+			message: `Could not parse vote JSON after one retry. Last error: ${second.error}.`,
+			raw: retryRaw.slice(0, 500)
+		}
+	};
+}
+function tryParseVote(raw) {
+	if (!raw || !raw.trim()) return {
+		ok: false,
+		error: "empty response"
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw.trim());
+	} catch {
+		const fence = /```(?:json)?\s*([\s\S]*?)\s*```/.exec(raw);
+		if (!fence) return {
+			ok: false,
+			error: "not valid JSON and no code fence found"
+		};
+		try {
+			parsed = JSON.parse(fence[1]);
+		} catch {
+			return {
+				ok: false,
+				error: "code fence content was not valid JSON"
+			};
+		}
+	}
+	if (typeof parsed !== "object" || parsed === null) return {
+		ok: false,
+		error: "parsed value is not an object"
+	};
+	const obj = parsed;
+	const choice = obj.choice === null ? null : typeof obj.choice === "string" && obj.choice.length > 0 ? obj.choice : void 0;
+	if (choice === void 0) return {
+		ok: false,
+		error: "missing or invalid 'choice' field (string or null required)"
+	};
+	const confidenceRaw = obj.confidence;
+	const confidence = typeof confidenceRaw === "number" && Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : void 0;
+	if (confidence === void 0) return {
+		ok: false,
+		error: "missing or invalid 'confidence' field (number 0-1 required)"
+	};
+	const reasoning = typeof obj.reasoning === "string" ? obj.reasoning : "";
+	if (!reasoning) return {
+		ok: false,
+		error: "missing or empty 'reasoning' field"
+	};
+	return {
+		ok: true,
+		vote: {
+			choice,
+			confidence,
+			reasoning,
+			needMoreInfo: typeof obj.need_more_info === "string" && obj.need_more_info.length > 0 ? obj.need_more_info : void 0
+		}
+	};
+}
+function aggregateVotes(results) {
+	const tally = /* @__PURE__ */ new Map();
+	for (const r of results) {
+		if (r.vote.choice === null) continue;
+		const entry = tally.get(r.vote.choice) ?? {
+			count: 0,
+			sumConfidence: 0
+		};
+		entry.count++;
+		entry.sumConfidence += r.vote.confidence;
+		tally.set(r.vote.choice, entry);
+	}
+	let topChoice = null;
+	let topCount = 0;
+	let topSumConfidence = 0;
+	for (const [choice, { count, sumConfidence }] of tally) if (count > topCount) {
+		topChoice = choice;
+		topCount = count;
+		topSumConfidence = sumConfidence;
+	}
+	const total = STAND_IN_MODELS.length;
+	if (topChoice && topCount === total) return {
+		verdict: "consensus",
+		winner: topChoice,
+		meanConfidence: topSumConfidence / topCount
+	};
+	if (topChoice && topCount >= 2) return {
+		verdict: "majority",
+		winner: topChoice,
+		meanConfidence: topSumConfidence / topCount
+	};
+	return {
+		verdict: "split",
+		winner: null,
+		meanConfidence: 0
+	};
+}
+function buildRound1UserText(input) {
+	const lines = [];
+	lines.push(`Decision: ${input.decision}`);
+	lines.push("");
+	lines.push("Options:");
+	for (const opt of input.options) {
+		const suffix = opt.detail ? ` — ${opt.detail}` : "";
+		lines.push(`- ${opt.id}: ${opt.summary}${suffix}`);
+	}
+	if (input.context) {
+		lines.push("");
+		lines.push("Context:");
+		lines.push(input.context);
+	}
+	return lines.join("\n");
+}
+function buildRound2UserTextBase(input, r1) {
+	const base = buildRound1UserText(input);
+	const summaries = ["", "Round 1 votes:"];
+	for (const r of r1) if (isVote(r.vote)) {
+		const choiceText = r.vote.choice === null ? "abstain" : r.vote.choice;
+		const gapText = r.vote.needMoreInfo ? ` (needs: ${r.vote.needMoreInfo})` : "";
+		summaries.push(`- ${r.key} picked ${choiceText}, confidence ${r.vote.confidence.toFixed(2)}, reasoning: ${r.vote.reasoning}${gapText}`);
+	} else summaries.push(`- ${r.key} did not return a valid round-1 vote (${r.vote.error}).`);
+	return base + "\n" + summaries.join("\n");
+}
+function isVote(v) {
+	return !("error" in v);
+}
+function voteRecord(r1, r2) {
+	const record = {};
+	for (const cfg of STAND_IN_MODELS) {
+		const r1Entry = r1.find((r) => r.key === cfg.key);
+		const r2Entry = r2?.find((r) => r.key === cfg.key) ?? null;
+		record[cfg.key] = {
+			round1: r1Entry?.vote ?? {
+				error: "upstream_error",
+				message: "no round-1 result recorded"
+			},
+			round2: r2Entry ? r2Entry.vote : null
+		};
+	}
+	return record;
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+
 //#endregion
 //#region src/lib/peer-mcp-personas.ts
 /**
@@ -8525,6 +8927,54 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				signal
 			});
 		}
+	},
+	{
+		toolNameHttp: "stand_in",
+		capability: "stand_in",
+		description: "**Away-mode decision tiebreak.** Three-lab advisor (gpt-5.5 xhigh, opus-4.7 xhigh, gemini-3.1-pro high) for **when the user is unavailable and you are stuck between two or more concrete options**. Polls all three across two structured rounds (blind vote → informed re-vote with peer reasoning visible) and returns a ranked-choice verdict. Use when: you would otherwise halt and wait for the user. Do NOT use for: code review (use `peer-review-coordinator`), open-ended exploration, single-model second opinions (use `codex_critic` / `gemini_critic` / `opus_critic` directly), or as a substitute for user confirmation on irreversible actions (push, delete, drop, deploy — those still require the user even with three-lab consensus).",
+		inputSchema: {
+			type: "object",
+			required: ["decision", "options"],
+			additionalProperties: false,
+			properties: {
+				decision: {
+					type: "string",
+					description: "One-sentence framing of the choice the user would otherwise make. Be specific about what's being decided, not why."
+				},
+				options: {
+					type: "array",
+					minItems: 2,
+					maxItems: 6,
+					description: "2-6 concrete options for the panel to vote on. Caller-provided — do NOT ask the panel to generate options. The verdict cites the chosen option by `id`.",
+					items: {
+						type: "object",
+						required: ["id", "summary"],
+						additionalProperties: false,
+						properties: {
+							id: {
+								type: "string",
+								description: "Short stable identifier the verdict refers to (e.g., \"A\", \"lib-x\")."
+							},
+							summary: {
+								type: "string",
+								description: "One-line description of the option."
+							},
+							detail: {
+								type: "string",
+								description: "Optional longer context for the option (constraints, trade-offs)."
+							}
+						}
+					}
+				},
+				context: {
+					type: "string",
+					description: "Task / code background that informs the decision. Keep tight — the input is capped at ~6KB total across decision + options + context."
+				}
+			}
+		},
+		async handler(args, signal) {
+			return runStandInToolCall(args, signal);
+		}
 	}
 ]);
 /**
@@ -8608,6 +9058,109 @@ async function runWorkerToolCall(call) {
 		isError: result.isError
 	};
 }
+/**
+* Shared closure body for the `stand_in` MCP tool. Validates the input
+* shape ({decision, options, context}) then calls `runStandIn`. The
+* orchestrator never throws — failure modes (upstream errors, parse
+* failures, abstains) all surface inside the structured `StandInResult`
+* envelope, which we JSON-stringify into the single MCP text block.
+*
+* Arg-validation policy mirrors `runWorkerToolCall` and `web_search`:
+* shape errors surface as `isError: true` tool-result envelopes (NOT
+* JSON-RPC -32602). The `tools/list` JSON schema documents required
+* fields; this runtime check is defense against a schema-ignoring
+* client.
+*
+* `isError` is FALSE for the no_consensus / need_more_info verdicts —
+* those are valid protocol outcomes the caller acts on, not errors.
+* `isError` is TRUE only for input-shape failures (bad arg types,
+* missing required fields).
+*/
+async function runStandInToolCall(args, signal) {
+	const decision = typeof args.decision === "string" ? args.decision : "";
+	if (!decision) return {
+		content: [{
+			type: "text",
+			text: "stand_in: arguments.decision is required (non-empty string)"
+		}],
+		isError: true
+	};
+	const optionsRaw = args.options;
+	if (!Array.isArray(optionsRaw)) return {
+		content: [{
+			type: "text",
+			text: "stand_in: arguments.options must be an array (2-6 entries)"
+		}],
+		isError: true
+	};
+	if (optionsRaw.length < 2 || optionsRaw.length > 6) return {
+		content: [{
+			type: "text",
+			text: `stand_in: arguments.options must contain 2-6 entries; got ${optionsRaw.length}`
+		}],
+		isError: true
+	};
+	const options = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	for (let i = 0; i < optionsRaw.length; i++) {
+		const entry = optionsRaw[i];
+		if (typeof entry !== "object" || entry === null) return {
+			content: [{
+				type: "text",
+				text: `stand_in: arguments.options[${i}] must be an object`
+			}],
+			isError: true
+		};
+		const e = entry;
+		const id = typeof e.id === "string" ? e.id : "";
+		const summary = typeof e.summary === "string" ? e.summary : "";
+		if (!id) return {
+			content: [{
+				type: "text",
+				text: `stand_in: arguments.options[${i}].id is required (non-empty string)`
+			}],
+			isError: true
+		};
+		if (!summary) return {
+			content: [{
+				type: "text",
+				text: `stand_in: arguments.options[${i}].summary is required (non-empty string)`
+			}],
+			isError: true
+		};
+		if (seenIds.has(id)) return {
+			content: [{
+				type: "text",
+				text: `stand_in: arguments.options[${i}].id="${id}" is duplicated; ids must be unique`
+			}],
+			isError: true
+		};
+		seenIds.add(id);
+		const detail = typeof e.detail === "string" && e.detail.length > 0 ? e.detail : void 0;
+		options.push({
+			id,
+			summary,
+			detail
+		});
+	}
+	const context = args.context === void 0 ? void 0 : typeof args.context === "string" ? args.context : null;
+	if (context === null) return {
+		content: [{
+			type: "text",
+			text: "stand_in: arguments.context must be a string when provided"
+		}],
+		isError: true
+	};
+	const result = await runStandIn({
+		decision,
+		options,
+		context
+	}, signal);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+}
 
 //#endregion
 //#region src/lib/codex-mcp-config.ts
@@ -9193,7 +9746,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.29";
+var version = "0.3.31";
 
 //#endregion
 //#region src/lib/approval.ts