github-router 0.3.247 → 0.3.249

package/dist/{peer-mcp-personas-EM3cQqlR.js → peer-mcp-personas-DJzLpfDJ.js}

@@ -16338,25 +16338,25 @@ async function provisionColbert() {
 }
 async function provisionBinary(asset, dest) {
 	const sidecar = `${dest}.sha256`;
-	if (existsSync(dest) && await sidecarMatches(sidecar, asset.sha256)) return;
+	if (await installedArtifactIsIntact(sidecar, dest, asset.sha256)) return;
 	await mkdir(path.dirname(dest), { recursive: true });
 	const archive = await download(asset.url);
 	verifySha(archive, asset.sha256, "colgrep binary");
 	const member = await extractMember(asset, archive, "colgrep");
 	if (!member) throw new Error("colgrep binary not found in archive");
 	await atomicWrite(dest, member, true);
-	await writeFile(sidecar, asset.sha256).catch(() => {});
+	await writeFile(sidecar, sidecarContent(asset.sha256, member)).catch(() => {});
 }
 async function provisionOrt(asset, dest) {
 	const sidecar = `${dest}.sha256`;
-	if (existsSync(dest) && await sidecarMatches(sidecar, asset.sha256)) return;
+	if (await installedArtifactIsIntact(sidecar, dest, asset.sha256)) return;
 	await mkdir(path.dirname(dest), { recursive: true });
 	const archive = await download(asset.url);
 	verifySha(archive, asset.sha256, "ONNX Runtime");
 	const member = await extractMember(asset, archive, asset.member ?? "");
 	if (!member) throw new Error("ORT dylib not found in archive");
 	await atomicWrite(dest, member, true);
-	await writeFile(sidecar, asset.sha256).catch(() => {});
+	await writeFile(sidecar, sidecarContent(asset.sha256, member)).catch(() => {});
 	if (process$1.platform !== "win32" && asset.soname) {
 		const link = path.join(path.dirname(dest), asset.soname);
 		await rm(link, { force: true }).catch(() => {});
@@ -16431,13 +16431,44 @@ async function atomicWrite(dest, bytes, executable) {
 		}
 	}
 }
-async function sidecarMatches(sidecar, sha256) {
+/**
+* Is the artifact already installed AND still the bytes we installed?
+*
+* Sidecar format is two whitespace-separated hashes: the ARCHIVE sha (which
+* manifest revision this came from) and the INSTALLED-FILE sha (what we wrote
+* to disk). Both are required.
+*
+* The archive hash alone is not enough, and trusting it caused a real outage.
+* `existsSync(dest) && sidecarMatches(archiveSha)` treats any file at the path
+* as good, so when a lane-1 test with a leaked `node:os` mock overwrote the
+* real `colgrep.exe` with a 6-byte stub, provisioning kept short-circuiting on
+* the still-valid sidecar and never re-downloaded. The smoke test then failed
+* every launch, removed `.smoke-ok`, and semantic search reported "unavailable
+* on this host" forever. Only manually deleting the binary could recover it.
+*
+* A legacy single-hash sidecar means the installed bytes were never recorded,
+* so their provenance is unknown. That returns false deliberately: one extra
+* download self-heals every install already corrupted by the above, which is
+* the whole point of checking.
+*
+* This matches what the model files already do (they hash installed content
+* before reuse); the binary and ORT were the two that skipped it.
+*/
+async function installedArtifactIsIntact(sidecar, dest, archiveSha) {
 	try {
-		return (await readFile(sidecar, "utf8")).trim() === sha256;
+		if (!existsSync(dest)) return false;
+		const [recordedArchive, recordedInstalled] = (await readFile(sidecar, "utf8")).trim().split(/\s+/);
+		if (recordedArchive !== archiveSha) return false;
+		if (!recordedInstalled) return false;
+		return createHash("sha256").update(await readFile(dest)).digest("hex") === recordedInstalled;
 	} catch {
 		return false;
 	}
 }
+/** Sidecar content pairing the archive revision with the installed bytes. */
+function sidecarContent(archiveSha, installed) {
+	return `${archiveSha}\n${createHash("sha256").update(installed).digest("hex")}`;
+}
 /**
 * Post-provision smoke test. Runs ONE cheap colgrep invocation with the
 * EXACT isolating env the runner uses (`COLGREP_DATA_DIR`,
@@ -17689,18 +17720,30 @@ function lexicalSearchCodeMode(mode) {
 * Status-specific, actionable fallback hint. The semantic index isn't ready,
 * so the model got LEXICAL results (great for exact symbols, sparse for a
 * natural-language phrase since the lexical backend matches literally). Tell
-* it both levers: retry `mode:"semantic"` shortly (the index is self-healing
-* in the background) OR re-query now with specific symbol/keyword terms.
+* it both levers: retry `mode:"semantic"` (the index is self-healing in the
+* background) OR re-query now with specific symbol/keyword terms.
+*
+* "shortly" was too vague and cost a real recovery. A build takes MINUTES on a
+* large repo, and after a failed build the FIRST query is consumed triggering
+* the re-kick and still returns a fallback. So a caller who retried once,
+* seconds later, saw a second fallback and concluded the tool was broken
+* rather than mid-repair. Observed end to end on this repo: query, then
+* ~5 minutes of `building`, then `ready`. Naming the timescale and the
+* one-query-to-trigger behaviour is what turns "it's still broken" into
+* "it's coming back".
+*
+* The wording stays a range rather than a number: build time scales with
+* repository size, so a hard figure would be wrong for most callers.
 */
 const FALLBACK_GUIDANCE_MARKER = "retry mode:\"semantic\"";
-const FALLBACK_GUIDANCE = `${FALLBACK_GUIDANCE_MARKER} shortly, or re-query now with specific symbol/keyword terms`;
+const FALLBACK_GUIDANCE = `${FALLBACK_GUIDANCE_MARKER} in a few minutes (a build takes minutes on a large repo), or re-query now with specific symbol/keyword terms`;
 function fallbackNoticeFor(status) {
 	const tail = FALLBACK_GUIDANCE;
 	switch (status) {
-		case "building": return `semantic index is building; returned lexical keyword matches — ${tail}`;
-		case "stale": return `semantic index predates the current HEAD/tree (a background re-index was started); returned lexical keyword matches — ${tail}`;
-		case "unavailable": return `no semantic index for this workspace yet (a background build was started); returned lexical keyword matches — ${tail}`;
-		case "failed": return `semantic index unavailable (build failing — see proxy logs); returned lexical keyword matches — ${tail}`;
+		case "building": return `semantic index is building; returned lexical keyword matches. ${tail}`;
+		case "stale": return `semantic index predates the current HEAD/tree (a background re-index was started); returned lexical keyword matches. ${tail}`;
+		case "unavailable": return `no semantic index for this workspace yet (a background build was started); returned lexical keyword matches. ${tail}`;
+		case "failed": return `semantic index unavailable; this query started a background rebuild, so it returned lexical keyword matches. ${tail}`;
 		default: return "returned lexical results";
 	}
 }
@@ -19876,6 +19919,20 @@ function detectAgentCall(input) {
 //#endregion
 //#region src/services/copilot/endpoint.ts
 /**
+* Catalog spellings that mean each of our two clients. Copilot is not
+* self-consistent about the `/v1` prefix — the live catalog advertises
+* `/v1/messages` prefixed but `/chat/completions` bare, and this repo's own
+* fixtures carry both forms — so an exact-match on the bare spelling alone
+* silently misses a real shape. `src/lib/model-validation.ts` already
+* normalizes the same way (`ENDPOINT_ALIASES`); this keeps the two agreeing.
+*
+* Matching is EXACT against this set, never a suffix/`includes` test: a
+* `ws:/responses` (websocket transport) entry is NOT the `/responses` HTTP
+* client and must keep resolving to "serves neither".
+*/
+const CHAT_ENDPOINTS = /* @__PURE__ */ new Set(["/chat/completions", "/v1/chat/completions"]);
+const RESPONSES_ENDPOINTS = /* @__PURE__ */ new Set(["/responses", "/v1/responses"]);
+/**
 * Decide which endpoint to call for a model from its catalog
 * `supported_endpoints`. Prefers `/chat/completions` when available (the
 * simpler, more widely-supported shape) and falls back to `/responses` for
@@ -19891,19 +19948,37 @@ function detectAgentCall(input) {
 function pickEndpoint(model) {
 	const eps = model.supported_endpoints;
 	if (!eps || eps.length === 0) return "chat";
-	if (eps.includes("/chat/completions")) return "chat";
-	if (eps.includes("/responses")) return "responses";
+	if (eps.some((e) => CHAT_ENDPOINTS.has(e))) return "chat";
+	if (eps.some((e) => RESPONSES_ENDPOINTS.has(e))) return "responses";
 }
 /**
-* `pickEndpoint` by model id against the live catalog. Returns "chat" when
-* the id isn't in the catalog (unknown models default to the chat shape,
-* matching the field-absent rule above) — callers that need a hard
-* presence check should look the model up themselves.
+* `pickEndpoint` by model id against the live catalog, WITHOUT collapsing
+* "absent from the catalog" into "serves neither of our endpoints".
+*
+* This function deliberately has no default. The predecessor
+* (`endpointForModelId`) returned `pickEndpoint(found) ?? "chat"`, which
+* coerced both cases to "chat" — defensible for an unknown id, silently wrong
+* for a catalog model serving only, say, `/v1/messages`: the caller would drive
+* it through the chat client and get an opaque upstream 400 with no local
+* signal about the real cause. `src/lib/browser-mcp/compressor.ts` already
+* treats that case correctly (`if (!endpoint) continue`); this makes the same
+* distinction available to callers that resolve by id.
+*
+* Callers that legitimately want the chat default for an unknown id can still
+* have it — they just have to write it, per case, on purpose.
 */
-function endpointForModelId(id) {
+function resolveEndpointForModelId(id) {
 	const found = state.models?.data?.find((m) => m.id === id);
-	if (!found) return "chat";
-	return pickEndpoint(found) ?? "chat";
+	if (!found) return { kind: "unknown-model" };
+	const endpoint = pickEndpoint(found);
+	if (endpoint) return {
+		kind: "endpoint",
+		endpoint
+	};
+	return {
+		kind: "unreachable",
+		endpoints: found.supported_endpoints ?? []
+	};
 }
 //#endregion
 //#region src/lib/browser-mcp/compressor.ts
@@ -24126,7 +24201,12 @@ async function runStreamLoop(stream, context, opts, options) {
 			return;
 		}
 	}
-	if (endpointForModelId(resolved.modelId) === "responses") {
+	const resolution = resolveEndpointForModelId(resolved.modelId);
+	if (resolution.kind === "unreachable") {
+		pushUndrivableModelDiagnostic(stream, resolved, resolution.endpoints);
+		return;
+	}
+	if (resolution.kind === "endpoint" && resolution.endpoint === "responses") {
 		await runResponsesStreamLoop(stream, context, opts, options);
 		return;
 	}
@@ -24950,6 +25030,33 @@ function pushBackstopDiagnostic(stream, resolved, assembledTokens, limitTokens)
 		error: final
 	});
 }
+/**
+* Terminal diagnostic for a model the worker cannot drive AT ALL: it is in the
+* live catalog, but its `supported_endpoints` name neither `/chat/completions`
+* nor `/responses` — our only two clients. Fails here, locally, naming the
+* model and what it actually serves, instead of coercing it onto the chat
+* client and surfacing an opaque upstream `unsupported_api_for_model` 400.
+* Carried as assistant TEXT so the engine surfaces it as an `isError` result
+* (same shape as the request-boundary backstop).
+*/
+function pushUndrivableModelDiagnostic(stream, resolved, endpoints) {
+	const served = endpoints.length > 0 ? endpoints.join(", ") : "(none advertised)";
+	const text = `Cannot run: ${resolved.modelId} is in the Copilot catalog but serves neither /chat/completions nor /responses — the only two APIs a worker can drive. Its catalog supported_endpoints are: ${served}. Pick a different model for this call, or change the mode default via worker_defaults (a zero-arg worker_defaults call lists the models a worker can be pointed at).`;
+	const final = {
+		...makeBaseMessage(resolved),
+		content: [{
+			type: "text",
+			text
+		}],
+		stopReason: "error",
+		errorMessage: `model ${resolved.modelId} serves no worker-drivable endpoint (${served})`
+	};
+	stream.push({
+		type: "error",
+		reason: "error",
+		error: final
+	});
+}
 function describeError(err) {
 	if (err instanceof HTTPError) return `${err.message} (status ${err.response.status})`;
 	if (err instanceof Error) return err.message;
@@ -30732,6 +30839,36 @@ function extractAssistantText(content) {
 	for (const part of content) if (part.type === "text") out += part.text;
 	return out;
 }
+/**
+* Banner that prefixes text salvaged from an EARLIER assistant turn when the
+* run ends without a usable final answer.
+*
+* It is deliberately loud. Recovered text is partial work — the model was
+* mid-investigation when it went quiet — and returning it bare would let the
+* caller read an interim note as a conclusion. That is a different bug from
+* the one this recovery fixes, and a worse one: silently wrong beats loudly
+* missing only for the model that produced it.
+*/
+const RECOVERED_TEXT_BANNER = "[recovered from an earlier turn — this run ended without a final answer, so the text below is partial work in progress, NOT a conclusion. Treat it as leads to verify, not as the worker's answer.]";
+/**
+* Compose the recovered-text block for a run that is ending with nothing
+* usable in its final turn.
+*
+* Returns `""` in the two cases where recovery would be noise: the run DID
+* produce live text (nothing was lost), or no turn ever produced any.
+*
+* Scope note: `highWater` is the LAST non-empty assistant text, not a
+* concatenation of every non-empty turn. Accumulating them would turn a
+* recovered result into a transcript dump — mostly interim narration — where
+* the last turn is both the most complete and the one the model was building
+* toward when it stalled.
+*/
+function recoveredBlock(liveText, highWater) {
+	if (liveText.trim()) return "";
+	const recovered = highWater.trim();
+	if (!recovered) return "";
+	return `${RECOVERED_TEXT_BANNER}\n\n${recovered}`;
+}
 const MAX_EMPTY_OUTPUT_NUDGES = 3;
 const EMPTY_OUTPUT_NUDGES = [
 	"Summarize your findings so far.",
@@ -30908,6 +31045,7 @@ async function runWorkerAgentOnce(opts) {
 		const abortHandler = () => agent.abort();
 		if (opts.signal) opts.signal.addEventListener("abort", abortHandler, { once: true });
 		let finalText = "";
+		let lastNonEmptyText = "";
 		let lastStopReason = null;
 		let nudgeCount = 0;
 		const maxEmptyOutputNudges = resolveMaxEmptyOutputNudges();
@@ -30934,6 +31072,7 @@ async function runWorkerAgentOnce(opts) {
 			const content = msg.content;
 			if (!Array.isArray(content)) return;
 			finalText = extractAssistantText(content);
+			if (finalText.trim()) lastNonEmptyText = finalText;
 			const sr = msg.stopReason;
 			if (typeof sr === "string") lastStopReason = sr;
 		});
@@ -30956,30 +31095,41 @@ async function runWorkerAgentOnce(opts) {
 			try {
 				await ws.remove();
 			} catch {}
-			const text = isBrowse ? terminalText ?? finalText : diff ? `${finalText}\n\n${diff}` : finalText;
+			const liveAnswer = isBrowse ? terminalText ?? finalText : finalText;
+			const recovered = recoveredBlock(liveAnswer, lastNonEmptyText);
+			const text = isBrowse ? liveAnswer : diff ? `${finalText}\n\n${diff}` : finalText;
 			if (lastStopReason === "error" || lastStopReason === "aborted") {
-				const diag = (terminalText ?? finalText).trim();
+				const diag = liveAnswer.trim();
 				let diagnostic;
 				if (lastStopReason === "aborted") diagnostic = wallClockExpired ? "[halted: wallclock]" : "[halted: cancelled]";
 				else diagnostic = diag || "Worker run failed before producing an answer — the model's input likely overflowed (a large tool result), or the upstream errored. Retry with a narrower task: target a specific section / file / element rather than reading everything at once.";
 				return {
 					text: lastStopReason === "aborted" ? [
 						diag,
+						recovered,
 						diff,
 						diagnostic
-					].filter(Boolean).join("\n\n") : [diagnostic, diff].filter(Boolean).join("\n\n"),
+					].filter(Boolean).join("\n\n") : [
+						diagnostic,
+						recovered,
+						diff
+					].filter(Boolean).join("\n\n"),
 					isError: true
 				};
 			}
 			if (budget.hardStopReason) return {
-				text: [text, `[halted: ${budget.hardStopReason}]`].filter(Boolean).join("\n\n"),
+				text: [
+					text,
+					recovered,
+					`[halted: ${budget.hardStopReason}]`
+				].filter(Boolean).join("\n\n"),
 				isError: true
 			};
 			if (!text.trim()) return {
-				text: `${NO_OUTPUT_PREFIX} after ${nudgeCount} nudges (stopReason=${lastStopReason ?? "unknown"}, turns=${budget.turns}, elapsed=${budget.elapsedMs}ms)]; retry with a different model via worker_defaults, or narrow/split the task.`,
+				text: [`${NO_OUTPUT_PREFIX} after ${nudgeCount} nudges (stopReason=${lastStopReason ?? "unknown"}, turns=${budget.turns}, elapsed=${budget.elapsedMs}ms)]; retry with a different model via worker_defaults, or narrow/split the task.`, recovered].filter(Boolean).join("\n\n"),
 				isError: true
 			};
-			return { text };
+			return { text: [text, recovered].filter(Boolean).join("\n\n") };
 		} catch (err) {
 			let diff = "";
 			try {
@@ -30992,7 +31142,12 @@ async function runWorkerAgentOnce(opts) {
 			} catch {}
 			const haltOrErr = err instanceof Error ? err.message : String(err);
 			const parts = [];
-			if (finalText) parts.push(finalText);
+			const liveAnswer = isBrowse ? terminalText ?? finalText : finalText;
+			if (liveAnswer.trim()) parts.push(liveAnswer);
+			else {
+				const recovered = recoveredBlock(liveAnswer, lastNonEmptyText);
+				if (recovered) parts.push(recovered);
+			}
 			if (diff) parts.push(diff);
 			parts.push(haltOrErr);
 			return {
@@ -35021,4 +35176,4 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 //#endregion
 export { searchWeb as $, DEFAULT_CLAUDE_MODEL_FALLBACKS as $t, trustRepo as A, state as An, getTokenCount as At, TEST_DEFAULT_MODEL as B, hasSupportedBrowserInstalled as Bt, fileLastPromptStore as C, fetchWithTransientRetry as Cn, scoutModel as Ct, repoRoot as D, copilotBaseUrl as Dn, shimDefaultsToXhigh as Dt, repoFingerprint as E, GITHUB_API_BASE_URL as En, workerToolsEnabled as Et, EXPLORE_DEFAULT_MODEL as F, createChatCompletions as Ft, buildEnv as G, CONDENSED_OPERATING_SEQUENCE as Gt, resolveModeDefaults as H, extractTarGzMember as Ht, EXPLORE_DEFAULT_THINKING as I, MAX_RESPONSE_BODY_BYTES as It, toolbeltEnabled as J, ArtifactClient as Jt, availableToolCommands as K, DEFINITION_OF_GREATNESS as Kt, IMPLEMENT_DEFAULT_MODEL as L, readResponseBodyCapped as Lt, resolveSealedGate as M, resolveMcpToolTimeoutMs as Mt, BROWSE_DEFAULT_MODEL as N, pickEndpoint as Nt, stopGateEnabledForRepo as O, copilotHeaders as On, countTokens as Ot, DEFAULT_MODEL as P, createResponses as Pt, assetFor as Q, toolbeltPathOverride as Qt, PLAN_DEFAULT_MODEL as R, parseJsonOrDiagnose as Rt, fileFindingsStore as S, getGitHubUser as Sn, reviewerModel as St, isSubagentContext as T, forwardError as Tn, standInToolEnabled as Tt, resolveWorkerRunOpts as U, extractZipMember as Ut, appendPlanReminder as V, provisionAndIndexColbert as Vt, runWorkerAgent as W, warmTreeSitterPool as Wt, vscodeRipgrepPath as X, buildWorkspaceHeaderJson as Xt, toolbeltSkipSet as Y, buildWorkspaceHeaderHelperCommand as Yt, TOOLBELT_TOOLS$1 as Z, collapsePathKeys as Zt, stopGateDisabled as _, isNullish as _n, browserCompoundToolsEnabled as _t, buildPeerAwarenessSnippet as a, generateRandomPort as an, buildAnthropicErrorEvent as at, stopReviewEnabled as b, sleep$3 as bn, geminiAvailable as bt, personasFor as c, withInstallLock as cn, logStreamError as ct, buildStopHookCommand as d, setupGitHubToken as dn, handleMcpDelete as dt, DEFAULT_CODEX_MODEL as en, ADVISOR_INTERNAL_TOOL_NAME as et, captureLaunchBaseline as f, tryRefreshAndRetry as fn, handleMcpPost as ft, launchBaselineKey as g, filterBetaHeader as gn, browseAgentEnabled as gt, injectStopHookIntoSettingsFile as h, cacheVSCodeVersion as hn, brainstormModel as ht, buildAgentPrompt as i, UPSTREAM_INACTIVITY_TIMEOUT_MS as in, isAdvisorRequested as it, liveExec as j, assembleResponsesPayload as jt, stopReviewStateDir as k, githubHeaders as kn, createMessages as kt, buildArtifactOpenHookCommand as l, setupCopilotToken as ln, readIteratorWithTimeout as lt, fileBlockBudget as m, cacheModels as mn, artifactToolsEnabled as mt, MCP_GROUPS as n, DEFAULT_PORT as nn, buildAdvisorStream as nt, buildPeerAwarenessSummary as o, pickClaudeDefault as on, buildOpenAIErrorEvent as ot, decideStopHook as p, cacheCopilotVersion as pn, agentToolsEnabled as pt, buildToolbeltAwareness as q, shouldUseInsecureTls as qt, assertMcpToolSurfaceConsistent as r, UPSTREAM_FETCH_TIMEOUT_MS as rn, injectAdvisorTool as rt, enumerateInjectedMcpToolNames as s, getPackageVersion as sn, isControllerClosedError as st, GROUP_META as t, DEFAULT_CODEX_MODEL_FALLBACKS as tn, ADVISOR_TOOL_INSTRUCTIONS as tt, buildSessionBindHookCommand as u, setupGitHubAgentToken as un, relayAnthropicStream as ut, stopGateId as v, resolveCodexModel as vn, browserToolsEnabled as vt, fileReviewDebounce as w, HTTPError as wn, scribeModel as wt, fileBaselineStore as x, getModels as xn, nativeSubagentModel as xt, stopGatePlanMode as y, resolveModel as yn, fleetToolsEnabled as yt, REVIEW_DEFAULT_MODEL as z, provisionBrowserAssets as zt };
 
-//# sourceMappingURL=peer-mcp-personas-EM3cQqlR.js.map
+//# sourceMappingURL=peer-mcp-personas-DJzLpfDJ.js.map