github-router 0.3.219 → 0.3.229

package/dist/{peer-mcp-personas-A6PytLD6.js → peer-mcp-personas-BKwMCOsl.js}

@@ -13335,40 +13335,47 @@ function deriveDefinitionName(node) {
 	return null;
 }
 /**
-* Collect EVERY definition node from the parse tree — top-level AND
-* nested (class methods, methods' inner functions, nested classes, …) —
-* so the outline is a COMPLETE structural map the model can rely on to
-* decide what to read. Recurses through non-definition wrappers (TS
-* `export_statement`, Python `decorated_definition`, C++
-* `template_declaration`, …) at the same depth, and INTO each definition
-* at depth+1 to surface its members.
-*
-* `defTypes` is the language's definition-node-type set. Each node yields
-* one entry; the `name` is derived per `deriveDefinitionName` (a node
-* with no recoverable name is skipped, but the walk still descends into
-* it so its named members aren't lost). Bounded at `MAX_OUTLINE_ENTRIES`.
-*/
+* Collect declarations that help a model navigate a file: top-level symbols
+* and members of class-like containers. Function-local variables and nested
+* helpers are deliberately omitted because they inflate the summary without
+* identifying useful read targets. Non-definition wrappers (exports,
+* decorators, templates) preserve the surrounding depth.
+*/
+const OUTLINE_MEMBER_CONTAINERS = new Set([
+	"class_declaration",
+	"class_definition",
+	"class_specifier",
+	"interface_declaration",
+	"annotation_type_declaration",
+	"impl_item",
+	"trait_item",
+	"struct_item",
+	"namespace_definition",
+	"module"
+]);
 function collectDefinitions(root, defTypes, signal) {
 	const out = [];
-	const visit = (node, depth) => {
+	const visit = (node, depth, includeDefinitions) => {
 		if (signal?.aborted || out.length >= MAX_OUTLINE_ENTRIES) return;
 		for (const child of node.namedChildren) {
 			if (signal?.aborted || out.length >= MAX_OUTLINE_ENTRIES) return;
 			if (defTypes.has(child.type)) {
-				const name = deriveDefinitionName(child);
-				if (name !== null) out.push({
-					kind: child.type,
-					name,
-					line: child.startPosition.row + 1,
-					depth
-				});
-				visit(child, depth + 1);
+				if (includeDefinitions) {
+					const name = deriveDefinitionName(child);
+					if (name !== null) out.push({
+						kind: child.type,
+						name,
+						line: child.startPosition.row + 1,
+						depth
+					});
+				}
+				if (includeDefinitions && OUTLINE_MEMBER_CONTAINERS.has(child.type)) visit(child, depth + 1, true);
 				continue;
 			}
-			visit(child, depth);
+			visit(child, depth, includeDefinitions);
 		}
 	};
-	visit(root, 0);
+	visit(root, 0, true);
 	return out;
 }
 /**
@@ -13512,10 +13519,10 @@ function confirmDefinitionSites(tree, source, language, hits, signal) {
 	return confirmed;
 }
 /**
-* Full structural outline of a single file — EVERY definition, top-level
-* AND nested (functions, classes, methods, nested functions, interfaces,
-* type aliases, enums, including exported / decorated / templated
-* wrappers). Each entry carries a `depth` (0 = top-level). Reuses the
+* Navigational structural outline of a single file: top-level declarations
+* plus class-like members (methods, fields, interface members), excluding
+* function-local variables and nested implementation helpers. Each entry
+* carries a `depth` (0 = top-level). Reuses the
 * shared grammar bundle and the same `Parser` the structural pass uses
 * — no second `Parser.init()`.
 *
@@ -13680,6 +13687,14 @@ var TreeSitterPool = class {
 			spawned: this.workersSpawned
 		};
 	}
+	/**
+	* Launch-time latency optimization: ready ONE worker and its grammar bundle.
+	* A single worker keeps startup CPU/memory bounded while removing the first
+	* query's initialization wait; normal demand still grows the pool lazily.
+	*/
+	async warm() {
+		return await this.ensureWorkers(1) > 0;
+	}
 	queue = [];
 	inflight = /* @__PURE__ */ new Map();
 	constructor() {
@@ -13695,18 +13710,19 @@ var TreeSitterPool = class {
 	*  callers onto one in-flight ensure so 8 simultaneous searches don't each
 	*  spawn a fresh batch. Returns the live worker count (0 → caller must fall
 	*  back to the in-process path). */
-	ensureWorkers() {
+	ensureWorkers(target = this.size) {
 		if (this.unavailable || this.shuttingDown) return Promise.resolve(0);
+		const desired = Math.max(1, Math.min(target, this.size));
 		const liveNow = this.workers.filter((w) => w.ready && w.loaded.size > 0).length;
-		if (liveNow >= this.size) return Promise.resolve(liveNow);
-		if (this.ensuring) return this.ensuring;
-		this.ensuring = this.doEnsureWorkers().finally(() => {
+		if (liveNow >= desired) return Promise.resolve(liveNow);
+		if (this.ensuring) return liveNow > 0 ? Promise.resolve(liveNow) : this.ensuring;
+		this.ensuring = this.doEnsureWorkers(desired).finally(() => {
 			this.ensuring = null;
 		});
-		return this.ensuring;
+		return liveNow > 0 ? Promise.resolve(liveNow) : this.ensuring;
 	}
-	async doEnsureWorkers() {
-		const need = this.size - this.workers.length;
+	async doEnsureWorkers(target) {
+		const need = target - this.workers.length;
 		const spawns = [];
 		for (let i = 0; i < need; i++) spawns.push(this.spawnWorker());
 		const spawned = await Promise.all(spawns);
@@ -13927,13 +13943,23 @@ var TreeSitterPool = class {
 			budgetHit: false
 		};
 		opts.signal.addEventListener("abort", onAbort, { once: true });
-		const budgetTimer = setTimeout(() => {
-			budgetHit = true;
-			stop();
-		}, opts.budgetMs);
-		budgetTimer.unref?.();
+		let budgetTimer;
 		try {
 			if (await this.ensureWorkers() === 0) return null;
+			if (opts.signal.aborted) return {
+				byFile,
+				budgetHit: false
+			};
+			if (opts.budgetMs <= 0) {
+				budgetHit = true;
+				stop();
+			} else {
+				budgetTimer = setTimeout(() => {
+					budgetHit = true;
+					stop();
+				}, opts.budgetMs);
+				budgetTimer.unref?.();
+			}
 			const dispatchFile = async (job, retried) => {
 				if (stopped) return;
 				const id = this.nextJobId++;
@@ -13964,7 +13990,7 @@ var TreeSitterPool = class {
 			};
 			await Promise.all(jobs.map((job) => dispatchFile(job, false)));
 		} finally {
-			clearTimeout(budgetTimer);
+			if (budgetTimer) clearTimeout(budgetTimer);
 			opts.signal.removeEventListener("abort", onAbort);
 		}
 		const stillLive = this.workers.some((w) => w.ready && w.loaded.size > 0);
@@ -14010,6 +14036,7 @@ function resolveWorkerPath() {
 let _pool = null;
 let _shutdownRegistered = false;
 let _testCrashOnceArmed = false;
+let _warmOverride;
 /**
 * The pool is ON by default for real (non-CI) runs and OFF under CI.
 *
@@ -14055,6 +14082,24 @@ function getTreeSitterPool() {
 	}
 	return _pool;
 }
+/**
+* Best-effort launch warm-up. Returns immediately when disabled/unavailable and
+* never rejects; lazy initialization remains the fallback after any failure.
+*/
+async function warmTreeSitterPool() {
+	if (process.env.GH_ROUTER_DISABLE_TS_POOL_WARMUP === "1") return;
+	const pool = getTreeSitterPool();
+	if (!pool) return;
+	try {
+		if (await (_warmOverride?.(pool) ?? pool.warm())) return;
+	} catch (err) {
+		consola.debug(`[code_search] tree-sitter pool warm-up failed; using lazy initialization: ${err.message}`);
+	}
+	if (_pool === pool) {
+		pool.shutdown();
+		_pool = null;
+	}
+}
 
 //#endregion
 //#region src/lib/worker-agent/paths.ts
@@ -14257,9 +14302,9 @@ const WALL_TIME_MS = 3e4;
 * Structural-pass settings. The wall-clock budget is checked between
 * files (NOT mid-parse — tree-sitter doesn't surface a usable cancel
 * hook in the web-tree-sitter binding we're on), so a single
-* pathological file can overrun by one file's parse-time. In practice
-* a single source file parses in well under 50ms; 200ms gives us
-* comfortable headroom for ~5-10 files even on cold cache.
+* pathological file can overrun by one file's parse-time. Worker/grammar
+* initialization is completed before this timer starts; the 200ms budget
+* therefore measures parsing only, on cold and warm queries alike.
 */
 const STRUCTURAL_BUDGET_MS = 200;
 let _structuralBudgetTestOverride = null;
@@ -14854,7 +14899,7 @@ async function runStructuralPassPooled(opts) {
 	}
 	return {
 		confirmedHitIndexes,
-		fallback: run.budgetHit ? `structural budget exceeded after parsing ${run.byFile.size}/${opts.cap} hits; retry with structural: "topN" or narrow your query` : null,
+		fallback: run.budgetHit ? `structural budget exceeded after parsing ${run.byFile.size}/${jobs.length} files; retry with structural: "topN" or narrow your query` : null,
 		outlinesByFile
 	};
 }
@@ -15184,26 +15229,23 @@ function dropAstGrepSecrets(env) {
 	return env;
 }
 /**
-* Resolve the ast-grep binary. Checks the toolbelt bin dir (where the
-* proxy materializes `sg` + `ast-grep`) AND the system PATH, trying `sg`
-* first then `ast-grep`. Returns an ABSOLUTE path or `null` when neither
-* is found. `resolveExecutable` honors PATHEXT on Windows and excludes
-* the cwd (no planted-`sg.exe` vector). The toolbelt dir is searched by
-* prepending it to a PATH copy so the same resolver handles both sources.
+* Resolve the ast-grep binary. Checks the known router-owned toolbelt paths
+* directly before consulting PATH for the unambiguous `ast-grep` name.
+* Returns an ABSOLUTE path or `null` when neither source has it.
 */
 function resolveAstGrep() {
 	const toolbeltDir = PATHS.TOOLBELT_BIN_DIR;
-	const sgInToolbelt = resolveExecutable("sg", { env: {
-		...process.env,
-		PATH: toolbeltDir
-	} });
-	if (sgInToolbelt) return sgInToolbelt;
-	const astGrep = resolveExecutable("ast-grep", { env: {
-		...process.env,
-		PATH: `${toolbeltDir}${path.delimiter}${pathEnvValue()}`
-	} });
-	if (astGrep) return astGrep;
-	return null;
+	const toolbeltNames = process.platform === "win32" ? [
+		"sg.exe",
+		"ast-grep.exe",
+		"sg",
+		"ast-grep"
+	] : ["sg", "ast-grep"];
+	for (const name of toolbeltNames) {
+		const candidate = path.resolve(toolbeltDir, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	return resolveExecutable("ast-grep", { env: process.env });
 }
 /**
 * Test-only override for the ast-grep resolver. `undefined` = use the real
@@ -15217,11 +15259,6 @@ let _astGrepResolverOverride;
 function resolveAstGrepForRun() {
 	return (_astGrepResolverOverride ?? resolveAstGrep)();
 }
-/** Read PATH case-insensitively from the live env. */
-function pathEnvValue() {
-	for (const key of Object.keys(process.env)) if (key.toLowerCase() === "path") return process.env[key] ?? "";
-	return "";
-}
 /**
 * Run ast-grep with `pattern` over `workspaceCanonical` and return its
 * matches in `RawHit` shape (relativized, 1-indexed). Read-only,
@@ -15243,7 +15280,7 @@ async function runAstGrep(opts) {
 	const binary = resolveAstGrepForRun();
 	if (!binary) return {
 		hits: [],
-		notice: "ast_pattern requires ast-grep (sg), which isn't available here; the model can run ast-grep directly or omit ast_pattern"
+		notice: `ast_pattern requires ast-grep, but no executable was found at ${PATHS.TOOLBELT_BIN_DIR} (sg/ast-grep) or on PATH (ast-grep); install ast-grep or omit ast_pattern`
 	};
 	if (!opts.lang || !/^[A-Za-z0-9_+-]{1,20}$/.test(opts.lang)) return {
 		hits: [],
@@ -15825,424 +15862,112 @@ function modelDirName() {
 const MODEL_ID = "LateOn-Code-edge";
 
 //#endregion
-//#region src/lib/colbert/index-store.ts
-const GIT_TIMEOUT_MS = 4e3;
-/** Grace window after a `building` write before a workspace with no live
-* build PID is declared `crashed` — covers the cross-process window where
-* one proxy wrote `building` but hasn't yet recorded the colgrep child PID. */
-const BUILD_SPAWN_GRACE_MS = 3e4;
-/**
-* Hash a workspace path the same way the metadata sidecar is keyed.
-* NOTE: this is the ROUTER-OWNED meta key, independent of colgrep's
-* internal xxh3 physical-dir key (we never need to predict colgrep's
-* key because we pass the workspace as colgrep's PATH arg and let it
-* route). A stable sha256-prefix of the canonical path is sufficient.
-*/
-function metaHashForWorkspace(workspace) {
-	const canonical = process$1.platform === "win32" ? nodePath.resolve(workspace).toLowerCase().replace(/\\/g, "/") : nodePath.resolve(workspace);
-	let h = 2166136261;
-	for (let i = 0; i < canonical.length; i++) {
-		h ^= canonical.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return (h >>> 0).toString(16).padStart(8, "0");
-}
-function metaPath(workspace) {
-	return nodePath.join(PATHS.COLBERT_META_DIR, `${metaHashForWorkspace(workspace)}.json`);
-}
-/** Read the sidecar metadata for a workspace (null if none yet). */
-async function readColbertMeta(workspace) {
-	try {
-		const raw = await fs.readFile(metaPath(workspace), "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed;
-		return null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Per-workspace write serializer. `runInit` issues a pre-spawn
-* `building` write, an `onSpawn` write that patches in the colgrep child
-* PID, and a final `ready`/`failed` write. Chaining them per workspace
-* guarantees the final write lands AFTER the (fire-and-forget) onSpawn
-* write, so a `ready` result is never clobbered back to `building` by a
-* late atomic-rename.
-*/
-const _metaWriteChains = /* @__PURE__ */ new Map();
-/** Atomically write the sidecar metadata for a workspace (serialized). */
-async function writeColbertMeta(meta) {
-	const key = metaHashForWorkspace(meta.workspace);
-	const next = (_metaWriteChains.get(key) ?? Promise.resolve()).then(() => writeColbertMetaUnchained(meta));
-	_metaWriteChains.set(key, next.then(() => void 0, () => void 0));
-	return next;
-}
-async function writeColbertMetaUnchained(meta) {
-	await fs.mkdir(PATHS.COLBERT_META_DIR, { recursive: true });
-	const dest = metaPath(meta.workspace);
-	const tmp = `${dest}.${process$1.pid}.${Math.random().toString(16).slice(2, 10)}.tmp`;
-	try {
-		await fs.writeFile(tmp, JSON.stringify(meta, null, 2));
-		await fs.rename(tmp, dest);
-	} catch (err) {
-		await fs.rm(tmp, { force: true }).catch(() => {});
-		throw err;
-	}
+//#region src/lib/toolbelt/extract.ts
+function baseName(p) {
+	const norm = p.replace(/\\/g, "/");
+	const idx = norm.lastIndexOf("/");
+	return idx === -1 ? norm : norm.slice(idx + 1);
 }
 /**
-* Whether a COMPLETED colgrep index exists on disk for this workspace.
-* The preflight uses this to distinguish `building`/`absent` (no
-* completed index → don't spawn a foreground colgrep) from a real
-* index. We scan COLGREP_DATA_DIR for any per-project dir containing a
-* `project.json` whose canonical path matches this workspace AND an
-* `index/metadata.json` marker.
+* Extract the first regular-file member whose basename equals
+* `wantBasename` from an **xz-compressed tarball** (`.tar.xz`).
+*
+* Node's `zlib` has no xz/lzma decoder and the project carries no xz
+* dependency, so this shells out to the system `tar` (universally
+* present on macOS/Linux, which is the ONLY place a `.tar.xz` is ever
+* fetched — the colgrep Windows asset is a `.zip` handled by
+* `extractZipMember`). The xz path therefore never runs on the Windows
+* primary deployment target.
+*
+* Safety: the archive is extracted into a fresh, caller-provided temp
+* dir (NOT the cwd) and we read back ONLY the named regular-file member.
+* `tar` is invoked with `shell:false` (argv array, no metacharacter
+* surface) and `--no-same-owner` so a hostile archive can't request a
+* uid/gid change. The colgrep tarball nests its binary one dir deep
+* (`colgrep-<triple>/colgrep`), so we search recursively for the
+* basename rather than assuming a flat layout, and never follow
+* symlinks during the walk (closes the escape-the-extract-dir vector).
+*
+* Returns the member bytes, or null if the member is absent or `tar`
+* fails. The provisioner treats null as "skip / mismatch".
 */
-async function completedIndexOnDisk(workspace) {
-	const indicesDir = PATHS.COLBERT_INDICES_DIR;
-	let names;
+async function extractTarXzMember(buf, wantBasename, tmpDir) {
+	const { spawn: spawn$1 } = await import("node:child_process");
+	const fs$2 = await import("node:fs/promises");
+	const path$1 = await import("node:path");
+	const archivePath = path$1.join(tmpDir, "archive.tar.xz");
+	const extractDir = path$1.join(tmpDir, "x");
 	try {
-		names = await fs.readdir(indicesDir);
+		await fs$2.mkdir(extractDir, { recursive: true });
+		await fs$2.writeFile(archivePath, buf);
 	} catch {
-		return false;
+		return null;
 	}
-	const wantCanonical = await realpathForCompare(workspace);
-	for (const name of names) {
-		if (name === ".gh-router-meta") continue;
-		const projJson = nodePath.join(indicesDir, name, "project.json");
-		let proj;
+	if (!await new Promise((resolve) => {
+		let child;
 		try {
-			proj = JSON.parse(await fs.readFile(projJson, "utf8"));
+			child = spawn$1("tar", [
+				"-xJf",
+				archivePath,
+				"-C",
+				extractDir,
+				"--no-same-owner"
+			], {
+				stdio: "ignore",
+				windowsHide: true
+			});
 		} catch {
-			continue;
+			resolve(false);
+			return;
 		}
-		const projPath = proj.path ?? proj.project_path;
-		if (!projPath) continue;
-		if (await realpathForCompare(projPath) !== wantCanonical) continue;
-		if (existsSync(nodePath.join(indicesDir, name, "index", "metadata.json"))) return true;
-		if (existsSync(nodePath.join(indicesDir, name, "index"))) try {
-			if ((await fs.readdir(nodePath.join(indicesDir, name, "index"))).length > 0) return true;
-		} catch {}
-	}
-	return false;
-}
-function canonicalForCompare(p) {
-	return process$1.platform === "win32" ? nodePath.resolve(p).toLowerCase().replace(/\\/g, "/") : nodePath.resolve(p);
-}
-/** Sync realpath-aware canonicalization (sibling of `realpathForCompare`,
-* for the on-a-timer inactivity probe which must be synchronous). */
-function canonicalRealpathSync(p) {
+		const timer = setTimeout(() => {
+			try {
+				child.kill("SIGKILL");
+			} catch {}
+			resolve(false);
+		}, 6e4);
+		timer.unref?.();
+		child.on("error", () => {
+			clearTimeout(timer);
+			resolve(false);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			resolve(code === 0);
+		});
+	})) return null;
+	const found = await findRegularFile(fs$2, path$1, extractDir, new Set([wantBasename, `${wantBasename}.exe`]), 6);
+	if (!found) return null;
 	try {
-		return canonicalForCompare(realpathSync(p));
+		return await fs$2.readFile(found);
 	} catch {
-		return canonicalForCompare(p);
+		return null;
 	}
 }
-/** Recursive (bytes, fileCount) of a directory; sync + best-effort. A
-* colgrep index is a bounded set of shards so the walk stays small. */
-function dirSizeSync(dir) {
-	let bytes = 0;
-	let count = 0;
+async function findRegularFile(fs$2, path$1, dir, wants, depthBudget) {
+	if (depthBudget < 0) return null;
 	let entries;
 	try {
-		entries = readdirSync(dir, { withFileTypes: true });
+		entries = await fs$2.readdir(dir, { withFileTypes: true });
 	} catch {
-		return [0, 0];
+		return null;
 	}
-	for (const e of entries) {
-		const p = nodePath.join(dir, e.name);
-		if (e.isDirectory()) {
-			const [b, c] = dirSizeSync(p);
-			bytes += b;
-			count += c;
-		} else try {
-			bytes += statSync(p).size;
-			count += 1;
-		} catch {}
+	for (const e of entries) if (e.isFile() && wants.has(e.name)) return path$1.join(dir, e.name);
+	for (const e of entries) if (e.isDirectory()) {
+		const hit = await findRegularFile(fs$2, path$1, path$1.join(dir, e.name), wants, depthBudget - 1);
+		if (hit) return hit;
 	}
-	return [bytes, count];
+	return null;
 }
 /**
-* (sync) Progress signature of a workspace's colgrep index dir for the init
-* inactivity watchdog: `${totalBytes}:${fileCount}` of the project dir, or
-* `null` if it isn't on disk yet. colgrep is SILENT on a non-TTY pipe
-* during the (potentially multi-hour) encode phase, so output is useless as
-* a progress signal — but it writes index shards incrementally, so a
-* changing signature means "still progressing" and a frozen one means
-* "hung". Successive signatures drive the watchdog: change ⇒ re-arm, frozen
-* ⇒ kill. Sync because it's called from a `setTimeout` (not awaited).
+* Extract the first REGULAR-FILE tar member whose basename equals
+* `wantBasename` (optionally with a `.exe` suffix). Returns its bytes,
+* or null if absent. `buf` is the gzip-compressed tarball.
 */
-function indexDirSignature(workspace) {
-	const indicesDir = PATHS.COLBERT_INDICES_DIR;
-	let names;
+function extractTarGzMember(buf, wantBasename) {
+	let tar;
 	try {
-		names = readdirSync(indicesDir);
-	} catch {
-		return null;
-	}
-	const want = canonicalRealpathSync(workspace);
-	for (const name of names) {
-		if (name === ".gh-router-meta") continue;
-		const dir = nodePath.join(indicesDir, name);
-		let proj;
-		try {
-			proj = JSON.parse(readFileSync(nodePath.join(dir, "project.json"), "utf8"));
-		} catch {
-			continue;
-		}
-		const projPath = proj.path ?? proj.project_path;
-		if (!projPath || canonicalRealpathSync(projPath) !== want) continue;
-		const [bytes, count] = dirSizeSync(dir);
-		return `${bytes}:${count}`;
-	}
-	return null;
-}
-/**
-* Realpath-aware canonicalization for matching a workspace against
-* colgrep's stored `project_path`. colgrep stores the OS realpath (e.g.
-* macOS `/tmp` → `/private/tmp`, Windows 8.3 short names), so a plain
-* `path.resolve` comparison misses. Falls back to `canonicalForCompare`
-* when realpath fails (path doesn't exist yet).
-*/
-async function realpathForCompare(p) {
-	try {
-		return canonicalForCompare(await fs.realpath(p));
-	} catch {
-		return canonicalForCompare(p);
-	}
-}
-/**
-* Compute the freshness verdict for a query against a workspace.
-*
-* Routing (per the dropped-fallback contract):
-*   - `failed`   — sidecar says failed → caller returns isError.
-*   - `building` — a tracked init is live OR no completed index on disk
-*                  → caller returns building notice (NO results).
-*   - `absent`   — never indexed → caller kicks a debounced background
-*                  init, returns absent (isError).
-*   - `stale`    — ready but HEAD moved / tree dirty since index → caller
-*                  returns stale notice (NO results, NO re-search).
-*   - `fresh`    — ready + completed index + HEAD matches + not newly
-*                  dirty → caller spawns colgrep search.
-*/
-async function freshnessVerdict(workspace) {
-	const meta = await readColbertMeta(workspace);
-	if (!meta || meta.status === "absent") return {
-		verdict: "absent",
-		meta
-	};
-	if (meta.status === "failed") return {
-		verdict: "failed",
-		meta
-	};
-	if (meta.status === "building") {
-		const pid = typeof meta.buildPid === "number" ? meta.buildPid : 0;
-		if (isInitInFlight(workspace) || pid > 0 && isPidAlive(pid)) return {
-			verdict: "building",
-			meta
-		};
-		const startedMs = meta.lastIndexedAt ? Date.parse(meta.lastIndexedAt) : NaN;
-		if (Number.isFinite(startedMs) && Date.now() - startedMs < BUILD_SPAWN_GRACE_MS) return {
-			verdict: "building",
-			meta
-		};
-		if (!await completedIndexOnDisk(workspace)) return {
-			verdict: "crashed",
-			meta
-		};
-	}
-	if (!await completedIndexOnDisk(workspace)) return {
-		verdict: "building",
-		meta
-	};
-	const git = await gitState(workspace);
-	if (!git.isRepo) return {
-		verdict: "fresh",
-		meta
-	};
-	const headMoved = meta.lastIndexedHead !== void 0 && git.head !== meta.lastIndexedHead;
-	const newlyDirty = git.dirty && meta.lastIndexedDirty !== true;
-	if (headMoved || newlyDirty) return {
-		verdict: "stale",
-		meta,
-		head: git.head,
-		dirty: git.dirty
-	};
-	return {
-		verdict: "fresh",
-		meta,
-		head: git.head,
-		dirty: git.dirty
-	};
-}
-/** Cheap, bounded git probe via the native-exe runner. */
-async function gitState(workspace) {
-	const git = resolveExecutable("git");
-	if (!git) return { isRepo: false };
-	try {
-		const inside = await runManagedExeCapture(git, [
-			"-C",
-			workspace,
-			"rev-parse",
-			"--is-inside-work-tree"
-		], {
-			timeoutMs: GIT_TIMEOUT_MS,
-			maxStdoutBytes: 64 * 1024
-		});
-		if (inside.code !== 0 || inside.stdout.trim() !== "true") return { isRepo: false };
-		const head = await runManagedExeCapture(git, [
-			"-C",
-			workspace,
-			"rev-parse",
-			"HEAD"
-		], {
-			timeoutMs: GIT_TIMEOUT_MS,
-			maxStdoutBytes: 64 * 1024
-		});
-		const status = await runManagedExeCapture(git, [
-			"-C",
-			workspace,
-			"status",
-			"--porcelain"
-		], {
-			timeoutMs: GIT_TIMEOUT_MS,
-			maxStdoutBytes: 1024 * 1024
-		});
-		return {
-			isRepo: true,
-			head: head.code === 0 ? head.stdout.trim() || void 0 : void 0,
-			dirty: status.code === 0 ? status.stdout.trim().length > 0 : void 0
-		};
-	} catch {
-		return { isRepo: false };
-	}
-}
-const _initInFlight = /* @__PURE__ */ new Set();
-/** True iff a background init for this workspace is already in flight. */
-function isInitInFlight(workspace) {
-	return _initInFlight.has(initKey(workspace));
-}
-/** Mark a background init started (debounce). Returns false if already running. */
-function tryClaimInit(workspace) {
-	const k = initKey(workspace);
-	if (_initInFlight.has(k)) return false;
-	_initInFlight.add(k);
-	return true;
-}
-/** Release the debounce claim (call in the init's finally). */
-function releaseInit(workspace) {
-	_initInFlight.delete(initKey(workspace));
-}
-function initKey(workspace) {
-	return `${MODEL_ID}::${canonicalForCompare(workspace)}`;
-}
-
-//#endregion
-//#region src/lib/toolbelt/extract.ts
-function baseName(p) {
-	const norm = p.replace(/\\/g, "/");
-	const idx = norm.lastIndexOf("/");
-	return idx === -1 ? norm : norm.slice(idx + 1);
-}
-/**
-* Extract the first regular-file member whose basename equals
-* `wantBasename` from an **xz-compressed tarball** (`.tar.xz`).
-*
-* Node's `zlib` has no xz/lzma decoder and the project carries no xz
-* dependency, so this shells out to the system `tar` (universally
-* present on macOS/Linux, which is the ONLY place a `.tar.xz` is ever
-* fetched — the colgrep Windows asset is a `.zip` handled by
-* `extractZipMember`). The xz path therefore never runs on the Windows
-* primary deployment target.
-*
-* Safety: the archive is extracted into a fresh, caller-provided temp
-* dir (NOT the cwd) and we read back ONLY the named regular-file member.
-* `tar` is invoked with `shell:false` (argv array, no metacharacter
-* surface) and `--no-same-owner` so a hostile archive can't request a
-* uid/gid change. The colgrep tarball nests its binary one dir deep
-* (`colgrep-<triple>/colgrep`), so we search recursively for the
-* basename rather than assuming a flat layout, and never follow
-* symlinks during the walk (closes the escape-the-extract-dir vector).
-*
-* Returns the member bytes, or null if the member is absent or `tar`
-* fails. The provisioner treats null as "skip / mismatch".
-*/
-async function extractTarXzMember(buf, wantBasename, tmpDir) {
-	const { spawn: spawn$1 } = await import("node:child_process");
-	const fs$2 = await import("node:fs/promises");
-	const path$1 = await import("node:path");
-	const archivePath = path$1.join(tmpDir, "archive.tar.xz");
-	const extractDir = path$1.join(tmpDir, "x");
-	try {
-		await fs$2.mkdir(extractDir, { recursive: true });
-		await fs$2.writeFile(archivePath, buf);
-	} catch {
-		return null;
-	}
-	if (!await new Promise((resolve) => {
-		let child;
-		try {
-			child = spawn$1("tar", [
-				"-xJf",
-				archivePath,
-				"-C",
-				extractDir,
-				"--no-same-owner"
-			], {
-				stdio: "ignore",
-				windowsHide: true
-			});
-		} catch {
-			resolve(false);
-			return;
-		}
-		const timer = setTimeout(() => {
-			try {
-				child.kill("SIGKILL");
-			} catch {}
-			resolve(false);
-		}, 6e4);
-		timer.unref?.();
-		child.on("error", () => {
-			clearTimeout(timer);
-			resolve(false);
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			resolve(code === 0);
-		});
-	})) return null;
-	const found = await findRegularFile(fs$2, path$1, extractDir, new Set([wantBasename, `${wantBasename}.exe`]), 6);
-	if (!found) return null;
-	try {
-		return await fs$2.readFile(found);
-	} catch {
-		return null;
-	}
-}
-async function findRegularFile(fs$2, path$1, dir, wants, depthBudget) {
-	if (depthBudget < 0) return null;
-	let entries;
-	try {
-		entries = await fs$2.readdir(dir, { withFileTypes: true });
-	} catch {
-		return null;
-	}
-	for (const e of entries) if (e.isFile() && wants.has(e.name)) return path$1.join(dir, e.name);
-	for (const e of entries) if (e.isDirectory()) {
-		const hit = await findRegularFile(fs$2, path$1, path$1.join(dir, e.name), wants, depthBudget - 1);
-		if (hit) return hit;
-	}
-	return null;
-}
-/**
-* Extract the first REGULAR-FILE tar member whose basename equals
-* `wantBasename` (optionally with a `.exe` suffix). Returns its bytes,
-* or null if absent. `buf` is the gzip-compressed tarball.
-*/
-function extractTarGzMember(buf, wantBasename) {
-	let tar;
-	try {
-		tar = gunzipSync(buf);
+		tar = gunzipSync(buf);
 	} catch {
 		return null;
 	}
@@ -16340,6 +16065,14 @@ function colgrepBinaryPath() {
 function colbertModelDir() {
 	return nodePath.join(PATHS.COLBERT_MODELS_DIR, "LateOn-Code-edge", modelDirName());
 }
+/**
+* Canonical model argument for every colgrep invocation and project lookup.
+* colgrep hashes the raw model string, so slash variants fork one physical
+* index into distinct project keys on Windows.
+*/
+function canonicalColbertModelDir() {
+	return nodePath.resolve(colbertModelDir());
+}
 /** Absolute path the provisioned ORT dylib lives at. */
 function colbertOrtDylibPath() {
 	const lib = ortLibAsset()?.member ?? "libonnxruntime.so";
@@ -16462,7 +16195,7 @@ async function provisionColbert() {
 		result.status = "incomplete";
 	});
 	if (result.binaryPath && result.ortDylibPath && result.modelDir) {
-		const smoke = await runSmokeTest(result.binaryPath, result.ortDylibPath, result.modelDir);
+		const smoke = await runSmokeTest(result.binaryPath, result.ortDylibPath);
 		if (smoke.ok) {
 			await writeFile(smokeMarkerPath(), expectedSmokeMarker()).catch(() => {});
 			result.status = "ready";
@@ -16591,72 +16324,461 @@ async function sidecarMatches(sidecar, sha256) {
 * scanning stderr for colgrep's exact "ignoring" warning — if present,
 * the dylib didn't load and we fail the smoke test even on exit 0.
 */
-async function runSmokeTest(binaryPath, ortDylibPath, modelDir) {
+async function runSmokeTest(binaryPath, ortDylibPath) {
 	const tmp = nodePath.join(PATHS.COLBERT_DIR, `smoke-${process$1.pid}-${randomBytes(4).toString("hex")}`);
 	const fixtureDir = nodePath.join(tmp, "fixture");
 	const dataDir = nodePath.join(tmp, "data");
 	try {
-		await mkdir(fixtureDir, { recursive: true });
-		await mkdir(dataDir, { recursive: true });
-		await writeFile(nodePath.join(fixtureDir, "smoke.py"), "def smoke_test_function():\n    return 1\n");
+		await mkdir(fixtureDir, { recursive: true });
+		await mkdir(dataDir, { recursive: true });
+		await writeFile(nodePath.join(fixtureDir, "smoke.py"), "def smoke_test_function():\n    return 1\n");
+	} catch {
+		return {
+			ok: false,
+			reason: "smoke fixture setup failed"
+		};
+	}
+	try {
+		const env = dropColgrepSecrets({
+			...process$1.env,
+			COLGREP_DATA_DIR: dataDir,
+			ORT_DYLIB_PATH: ortDylibPath,
+			COLGREP_FORCE_CPU: "1",
+			PATH: `${nodePath.dirname(ortDylibPath)}${nodePath.delimiter}${process$1.env.PATH ?? ""}`
+		});
+		const res = await runManagedExeCapture(binaryPath, [
+			"search",
+			"--json",
+			"--color",
+			"never",
+			"--force-cpu",
+			"--model",
+			canonicalColbertModelDir(),
+			"-y",
+			"-k",
+			"1",
+			"smoke",
+			fixtureDir
+		], {
+			env,
+			timeoutMs: SMOKE_TIMEOUT_MS,
+			maxStdoutBytes: 4 * 1024 * 1024
+		});
+		if (res.timedOut) return {
+			ok: false,
+			reason: "smoke test timed out"
+		};
+		if (res.code !== 0) return {
+			ok: false,
+			reason: `colgrep exited ${res.code}`
+		};
+		if (/not a loadable onnx runtime dylib/i.test(res.stderr)) return {
+			ok: false,
+			reason: "ORT dylib failed to load (ORT_DYLIB_PATH ignored)"
+		};
+		return { ok: true };
+	} catch (err) {
+		consola.debug("colbert: smoke test spawn failed:", err);
+		return {
+			ok: false,
+			reason: "colgrep failed to launch (AV quarantine / missing runtime?)"
+		};
+	} finally {
+		await rm(tmp, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+}
+
+//#endregion
+//#region src/lib/colbert/index-store.ts
+const GIT_TIMEOUT_MS = 4e3;
+/** Grace window after a `building` write before a workspace with no live
+* build PID is declared `crashed` — covers the cross-process window where
+* one proxy wrote `building` but hasn't yet recorded the colgrep child PID. */
+const BUILD_SPAWN_GRACE_MS = 3e4;
+/**
+* Hash a workspace path the same way the metadata sidecar is keyed.
+* NOTE: this is the ROUTER-OWNED meta key, independent of colgrep's
+* internal xxh3 physical-dir key (we never need to predict colgrep's
+* key because we pass the workspace as colgrep's PATH arg and let it
+* route). A stable sha256-prefix of the canonical path is sufficient.
+*/
+function metaHashForWorkspace(workspace) {
+	const canonical = process$1.platform === "win32" ? nodePath.resolve(workspace).toLowerCase().replace(/\\/g, "/") : nodePath.resolve(workspace);
+	let h = 2166136261;
+	for (let i = 0; i < canonical.length; i++) {
+		h ^= canonical.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+function metaPath(workspace) {
+	return nodePath.join(PATHS.COLBERT_META_DIR, `${metaHashForWorkspace(workspace)}.json`);
+}
+/** Read the sidecar metadata for a workspace (null if none yet). */
+async function readColbertMeta(workspace) {
+	try {
+		const raw = await fs.readFile(metaPath(workspace), "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Per-workspace write serializer. `runInit` issues a pre-spawn
+* `building` write, an `onSpawn` write that patches in the colgrep child
+* PID, and a final `ready`/`failed` write. Chaining them per workspace
+* guarantees the final write lands AFTER the (fire-and-forget) onSpawn
+* write, so a `ready` result is never clobbered back to `building` by a
+* late atomic-rename.
+*/
+const _metaWriteChains = /* @__PURE__ */ new Map();
+/** Atomically write the sidecar metadata for a workspace (serialized). */
+async function writeColbertMeta(meta) {
+	const key = metaHashForWorkspace(meta.workspace);
+	const next = (_metaWriteChains.get(key) ?? Promise.resolve()).then(() => writeColbertMetaUnchained(meta));
+	_metaWriteChains.set(key, next.then(() => void 0, () => void 0));
+	return next;
+}
+async function writeColbertMetaUnchained(meta) {
+	await fs.mkdir(PATHS.COLBERT_META_DIR, { recursive: true });
+	const dest = metaPath(meta.workspace);
+	const tmp = `${dest}.${process$1.pid}.${Math.random().toString(16).slice(2, 10)}.tmp`;
+	try {
+		await fs.writeFile(tmp, JSON.stringify(meta, null, 2));
+		await fs.rename(tmp, dest);
+	} catch (err) {
+		await fs.rm(tmp, { force: true }).catch(() => {});
+		throw err;
+	}
+}
+/**
+* Whether a COMPLETED colgrep index exists on disk for this workspace.
+* The preflight uses this to distinguish `building`/`absent` (no
+* completed index → don't spawn a foreground colgrep) from a real
+* index. We scan COLGREP_DATA_DIR for any per-project dir containing a
+* `project.json` whose canonical path matches this workspace AND an
+* `index/metadata.json` marker.
+*/
+async function colbertProjectDir(workspace) {
+	const indicesDir = PATHS.COLBERT_INDICES_DIR;
+	let names;
+	try {
+		names = await fs.readdir(indicesDir);
+	} catch {
+		return null;
+	}
+	const wantCanonical = await realpathForCompare(workspace);
+	for (const name of names) {
+		if (name === ".gh-router-meta" || name.includes(".corrupt-")) continue;
+		const dir = nodePath.join(indicesDir, name);
+		let proj;
+		try {
+			proj = JSON.parse(await fs.readFile(nodePath.join(dir, "project.json"), "utf8"));
+		} catch {
+			continue;
+		}
+		const projPath = proj.path ?? proj.project_path;
+		if (!projPath || await realpathForCompare(projPath) !== wantCanonical) continue;
+		if (proj.model !== canonicalColbertModelDir()) continue;
+		return dir;
+	}
+	return null;
+}
+/** Validate the contiguous embedding interval encoded by PLAID shard metadata. */
+function validateIndexIntegrity(projectIndexDir) {
+	let names;
+	try {
+		names = readdirSync(projectIndexDir).filter((name) => /^\d+\.metadata\.json$/.test(name));
+	} catch (err) {
+		return err.code === "ENOENT" ? { verdict: "not-built" } : {
+			verdict: "corrupt",
+			reason: "index directory unreadable"
+		};
+	}
+	if (names.length === 0) return { verdict: "not-built" };
+	const intervals = [];
+	for (const name of names) try {
+		const parsed = JSON.parse(readFileSync(nodePath.join(projectIndexDir, name), "utf8"));
+		const start = parsed.embedding_offset;
+		const count = parsed.num_embeddings;
+		if (typeof start !== "number" || typeof count !== "number" || !Number.isSafeInteger(start) || !Number.isSafeInteger(count) || start < 0 || count < 0) return {
+			verdict: "corrupt",
+			reason: `invalid shard metadata: ${name}`
+		};
+		intervals.push({
+			start,
+			count
+		});
+	} catch {
+		return {
+			verdict: "corrupt",
+			reason: `unreadable shard metadata: ${name}`
+		};
+	}
+	intervals.sort((a, b) => a.start - b.start || a.count - b.count);
+	let cursorEnd = 0;
+	let sum = 0;
+	let gapped = false;
+	for (const interval of intervals) {
+		if (interval.start < cursorEnd) return {
+			verdict: "corrupt",
+			reason: "overlapping shard intervals"
+		};
+		if (interval.start > cursorEnd) gapped = true;
+		cursorEnd = interval.start + interval.count;
+		sum += interval.count;
+	}
+	if (gapped) return {
+		verdict: "suspect",
+		reason: "gap between shard intervals"
+	};
+	return {
+		verdict: "coherent",
+		shardCount: intervals.length,
+		embeddingCount: sum
+	};
+}
+async function completedIndexOnDisk(workspace) {
+	const projectDir = await colbertProjectDir(workspace);
+	if (!projectDir) return false;
+	return validateIndexIntegrity(nodePath.join(projectDir, "index")).verdict !== "not-built";
+}
+function canonicalForCompare(p) {
+	return process$1.platform === "win32" ? nodePath.resolve(p).toLowerCase().replace(/\\/g, "/") : nodePath.resolve(p);
+}
+/** Sync realpath-aware canonicalization (sibling of `realpathForCompare`,
+* for the on-a-timer inactivity probe which must be synchronous). */
+function canonicalRealpathSync(p) {
+	try {
+		return canonicalForCompare(realpathSync(p));
+	} catch {
+		return canonicalForCompare(p);
+	}
+}
+/** Recursive (bytes, fileCount) of a directory; sync + best-effort. A
+* colgrep index is a bounded set of shards so the walk stays small. */
+function dirSizeSync(dir) {
+	let bytes = 0;
+	let count = 0;
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [0, 0];
+	}
+	for (const e of entries) {
+		const p = nodePath.join(dir, e.name);
+		if (e.isDirectory()) {
+			const [b, c] = dirSizeSync(p);
+			bytes += b;
+			count += c;
+		} else try {
+			bytes += statSync(p).size;
+			count += 1;
+		} catch {}
+	}
+	return [bytes, count];
+}
+/**
+* (sync) Progress signature of a workspace's colgrep index dir for the init
+* inactivity watchdog: `${totalBytes}:${fileCount}` of the project dir, or
+* `null` if it isn't on disk yet. colgrep is SILENT on a non-TTY pipe
+* during the (potentially multi-hour) encode phase, so output is useless as
+* a progress signal — but it writes index shards incrementally, so a
+* changing signature means "still progressing" and a frozen one means
+* "hung". Successive signatures drive the watchdog: change ⇒ re-arm, frozen
+* ⇒ kill. Sync because it's called from a `setTimeout` (not awaited).
+*/
+function indexDirSignature(workspace) {
+	const indicesDir = PATHS.COLBERT_INDICES_DIR;
+	let names;
+	try {
+		names = readdirSync(indicesDir);
+	} catch {
+		return null;
+	}
+	const want = canonicalRealpathSync(workspace);
+	for (const name of names) {
+		if (name === ".gh-router-meta") continue;
+		if (name.includes(".corrupt-")) continue;
+		const dir = nodePath.join(indicesDir, name);
+		let proj;
+		try {
+			proj = JSON.parse(readFileSync(nodePath.join(dir, "project.json"), "utf8"));
+		} catch {
+			continue;
+		}
+		const projPath = proj.path ?? proj.project_path;
+		if (!projPath || canonicalRealpathSync(projPath) !== want) continue;
+		const [bytes, count] = dirSizeSync(dir);
+		return `${bytes}:${count}`;
+	}
+	return null;
+}
+/**
+* Realpath-aware canonicalization for matching a workspace against
+* colgrep's stored `project_path`. colgrep stores the OS realpath (e.g.
+* macOS `/tmp` → `/private/tmp`, Windows 8.3 short names), so a plain
+* `path.resolve` comparison misses. Falls back to `canonicalForCompare`
+* when realpath fails (path doesn't exist yet).
+*/
+async function realpathForCompare(p) {
+	try {
+		return canonicalForCompare(await fs.realpath(p));
 	} catch {
-		return {
-			ok: false,
-			reason: "smoke fixture setup failed"
+		return canonicalForCompare(p);
+	}
+}
+/**
+* Compute the freshness verdict for a query against a workspace.
+*
+* Routing (per the dropped-fallback contract):
+*   - `failed`   — sidecar says failed → caller returns isError.
+*   - `building` — a tracked init is live OR no completed index on disk
+*                  → caller returns building notice (NO results).
+*   - `absent`   — never indexed → caller kicks a debounced background
+*                  init, returns absent (isError).
+*   - `stale`    — ready but HEAD moved / tree dirty since index → caller
+*                  returns stale notice (NO results, NO re-search).
+*   - `fresh`    — ready + completed index + HEAD matches + not newly
+*                  dirty → caller spawns colgrep search.
+*/
+async function freshnessVerdict(workspace) {
+	const meta = await readColbertMeta(workspace);
+	if (!meta || meta.status === "absent") return {
+		verdict: "absent",
+		meta
+	};
+	if (meta.status === "failed") return {
+		verdict: "failed",
+		meta
+	};
+	if (meta.status === "building") {
+		const pid = typeof meta.buildPid === "number" ? meta.buildPid : 0;
+		if (isInitInFlight(workspace) || pid > 0 && isPidAlive(pid)) return {
+			verdict: "building",
+			meta
+		};
+		const startedMs = meta.lastIndexedAt ? Date.parse(meta.lastIndexedAt) : NaN;
+		if (Number.isFinite(startedMs) && Date.now() - startedMs < BUILD_SPAWN_GRACE_MS) return {
+			verdict: "building",
+			meta
+		};
+		if (!await completedIndexOnDisk(workspace)) return {
+			verdict: "crashed",
+			meta
 		};
 	}
+	const projectDir = await colbertProjectDir(workspace);
+	if (!projectDir) return {
+		verdict: "building",
+		meta
+	};
+	const integrity = validateIndexIntegrity(nodePath.join(projectDir, "index"));
+	if (integrity.verdict === "not-built") return {
+		verdict: "building",
+		meta
+	};
+	if (integrity.verdict === "corrupt") return {
+		verdict: "corrupt",
+		meta
+	};
+	if (integrity.verdict === "suspect") return {
+		verdict: "stale",
+		meta
+	};
+	const binarySha = colgrepBinAsset()?.sha256;
+	const ortSha = ortLibAsset()?.sha256;
+	if (binarySha && meta.binarySha !== binarySha || ortSha && meta.ortSha !== ortSha) return {
+		verdict: "stale",
+		meta
+	};
+	const git = await gitState(workspace);
+	if (!git.isRepo) return {
+		verdict: "fresh",
+		meta
+	};
+	const headMoved = meta.lastIndexedHead !== void 0 && git.head !== meta.lastIndexedHead;
+	const newlyDirty = git.dirty && meta.lastIndexedDirty !== true;
+	if (headMoved || newlyDirty) return {
+		verdict: "stale",
+		meta,
+		head: git.head,
+		dirty: git.dirty
+	};
+	return {
+		verdict: "fresh",
+		meta,
+		head: git.head,
+		dirty: git.dirty
+	};
+}
+/** Cheap, bounded git probe via the native-exe runner. */
+async function gitState(workspace) {
+	const git = resolveExecutable("git");
+	if (!git) return { isRepo: false };
 	try {
-		const env = dropColgrepSecrets({
-			...process$1.env,
-			COLGREP_DATA_DIR: dataDir,
-			ORT_DYLIB_PATH: ortDylibPath,
-			COLGREP_FORCE_CPU: "1",
-			PATH: `${nodePath.dirname(ortDylibPath)}${nodePath.delimiter}${process$1.env.PATH ?? ""}`
+		const inside = await runManagedExeCapture(git, [
+			"-C",
+			workspace,
+			"rev-parse",
+			"--is-inside-work-tree"
+		], {
+			timeoutMs: GIT_TIMEOUT_MS,
+			maxStdoutBytes: 64 * 1024
 		});
-		const res = await runManagedExeCapture(binaryPath, [
-			"search",
-			"--json",
-			"--color",
-			"never",
-			"--force-cpu",
-			"--model",
-			modelDir,
-			"-y",
-			"-k",
-			"1",
-			"smoke",
-			fixtureDir
+		if (inside.code !== 0 || inside.stdout.trim() !== "true") return { isRepo: false };
+		const head = await runManagedExeCapture(git, [
+			"-C",
+			workspace,
+			"rev-parse",
+			"HEAD"
 		], {
-			env,
-			timeoutMs: SMOKE_TIMEOUT_MS,
-			maxStdoutBytes: 4 * 1024 * 1024
+			timeoutMs: GIT_TIMEOUT_MS,
+			maxStdoutBytes: 64 * 1024
+		});
+		const status = await runManagedExeCapture(git, [
+			"-C",
+			workspace,
+			"status",
+			"--porcelain"
+		], {
+			timeoutMs: GIT_TIMEOUT_MS,
+			maxStdoutBytes: 1024 * 1024
 		});
-		if (res.timedOut) return {
-			ok: false,
-			reason: "smoke test timed out"
-		};
-		if (res.code !== 0) return {
-			ok: false,
-			reason: `colgrep exited ${res.code}`
-		};
-		if (/not a loadable onnx runtime dylib/i.test(res.stderr)) return {
-			ok: false,
-			reason: "ORT dylib failed to load (ORT_DYLIB_PATH ignored)"
-		};
-		return { ok: true };
-	} catch (err) {
-		consola.debug("colbert: smoke test spawn failed:", err);
 		return {
-			ok: false,
-			reason: "colgrep failed to launch (AV quarantine / missing runtime?)"
+			isRepo: true,
+			head: head.code === 0 ? head.stdout.trim() || void 0 : void 0,
+			dirty: status.code === 0 ? status.stdout.trim().length > 0 : void 0
 		};
-	} finally {
-		await rm(tmp, {
-			recursive: true,
-			force: true
-		}).catch(() => {});
+	} catch {
+		return { isRepo: false };
 	}
 }
+const _initInFlight = /* @__PURE__ */ new Set();
+/** True iff a background init for this workspace is already in flight. */
+function isInitInFlight(workspace) {
+	return _initInFlight.has(initKey(workspace));
+}
+/** Mark a background init started (debounce). Returns false if already running. */
+function tryClaimInit(workspace) {
+	const k = initKey(workspace);
+	if (_initInFlight.has(k)) return false;
+	_initInFlight.add(k);
+	return true;
+}
+/** Release the debounce claim (call in the init's finally). */
+function releaseInit(workspace) {
+	_initInFlight.delete(initKey(workspace));
+}
+function initKey(workspace) {
+	return `${MODEL_ID}::${canonicalForCompare(workspace)}`;
+}
 
 //#endregion
 //#region src/lib/colbert/runner.ts
@@ -16727,6 +16849,10 @@ function makeIndexProgressProbe(workspace) {
 * colgrep writer per workspace" goal as the init debounce. Cleared when the
 * detached search completes. */
 const _searchIndexInFlight = /* @__PURE__ */ new Set();
+const _initPromises = /* @__PURE__ */ new Map();
+/** In-flight quarantine deletions, drained by teardown (Windows EBUSY). */
+const _quarantineRemovals = /* @__PURE__ */ new Set();
+let _runManagedExeCapture = runManagedExeCapture;
 /** Build the isolating env for any colgrep child (search or init). */
 function colgrepEnv() {
 	const ortDir = nodePath.dirname(colbertOrtDylibPath());
@@ -16764,6 +16890,7 @@ async function runSemanticSearch(opts) {
 			};
 		case "failed": return handleFailure(workspace, fresh.meta, false);
 		case "crashed": return handleFailure(workspace, fresh.meta, true);
+		case "corrupt": return repairCorruptIndex(workspace, fresh.meta);
 		case "building": return {
 			status: "building",
 			notice: "semantic index is being built for this workspace; retry shortly (or use code_search now)"
@@ -16796,6 +16923,64 @@ async function runSemanticSearch(opts) {
 * by the inactivity watchdog) retries at most once — re-running a hung build
 * usually hangs again; transient classes retry up to `MAX_FAILED_ATTEMPTS`.
 */
+async function quarantineProjectDir(projectDir) {
+	const quarantine = `${projectDir}.corrupt-${process$1.pid}-${randomBytes(4).toString("hex")}`;
+	try {
+		await fs.rename(projectDir, quarantine);
+	} catch (err) {
+		consola.debug("colbert: corrupt index quarantine rename failed:", err);
+		return false;
+	}
+	const removal = fs.rm(quarantine, {
+		recursive: true,
+		force: true
+	}).catch((err) => {
+		consola.debug("colbert: corrupt index quarantine cleanup failed:", err);
+	}).finally(() => {
+		_quarantineRemovals.delete(removal);
+	});
+	_quarantineRemovals.add(removal);
+	return true;
+}
+async function repairCorruptIndex(workspace, meta) {
+	const wsKey = nodePath.resolve(workspace);
+	const attempts = (meta?.failureClass === "corrupt" ? meta.failedAttempts ?? 0 : 0) + 1;
+	const failedMeta = {
+		workspace,
+		model: meta?.model ?? MODEL_ID,
+		modelRev: meta?.modelRev ?? MODEL_REVISION,
+		binarySha: colgrepBinAsset()?.sha256,
+		ortSha: ortLibAsset()?.sha256,
+		status: "failed",
+		failureClass: "corrupt",
+		failedAttempts: attempts,
+		lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		lastIndexedHead: meta?.lastIndexedHead,
+		lastIndexedDirty: meta?.lastIndexedDirty,
+		ownerInstanceId: getColbertInstanceUuid()
+	};
+	if (_searchIndexInFlight.has(wsKey) || isInitInFlight(workspace)) return {
+		status: "building",
+		notice: "semantic index was found corrupt but a writer is still active; returned results are disabled until it exits"
+	};
+	const projectDir = await colbertProjectDir(workspace);
+	if (!projectDir) return handleFailure(workspace, failedMeta, false);
+	if (!await quarantineProjectDir(projectDir)) {
+		await writeColbertMeta(failedMeta).catch(() => {});
+		return {
+			status: "failed",
+			isError: true,
+			notice: "semantic index is corrupt but could not be quarantined; returned lexical results — close active colgrep processes and retry"
+		};
+	}
+	await writeColbertMeta(failedMeta).catch(() => {});
+	if (attempts < 2) kickBackgroundInit(workspace);
+	return {
+		status: "failed",
+		isError: true,
+		notice: attempts < 2 ? "semantic index was found corrupt and quarantined; a clean rebuild was started — retry mode:\"semantic\" shortly" : "semantic index repeatedly failed integrity checks; automatic rebuild is capped — do NOT retry mode:\"semantic\", use lexical search with specific symbol/keyword terms and see proxy logs"
+	};
+}
 async function handleFailure(workspace, meta, crashedVerdict) {
 	const cls = crashedVerdict ? "crashed" : meta?.failureClass ?? "error";
 	const attempts = crashedVerdict ? (meta?.failedAttempts ?? 0) + 1 : meta?.failedAttempts ?? 1;
@@ -16812,7 +16997,7 @@ async function handleFailure(workspace, meta, crashedVerdict) {
 		lastIndexedDirty: meta?.lastIndexedDirty,
 		ownerInstanceId: getColbertInstanceUuid()
 	}).catch(() => {});
-	const cap = cls === "stuck" ? 2 : MAX_FAILED_ATTEMPTS;
+	const cap = cls === "stuck" || cls === "corrupt" ? 2 : MAX_FAILED_ATTEMPTS;
 	const lastMs = lastAt ? Date.parse(lastAt) : NaN;
 	const backoffElapsed = !Number.isFinite(lastMs) || Date.now() - lastMs >= FAILED_RETRY_BACKOFF_MS;
 	if (attempts < cap && backoffElapsed) {
@@ -16855,7 +17040,7 @@ async function spawnSearch(opts) {
 		"never",
 		"--force-cpu",
 		"--model",
-		colbertModelDir(),
+		canonicalColbertModelDir(),
 		"-y",
 		"-k",
 		String(opts.limit)
@@ -16870,7 +17055,7 @@ async function spawnSearch(opts) {
 	_searchIndexInFlight.add(wsKey);
 	let searchPromise;
 	try {
-		searchPromise = runManagedExeCapture(binary, args, {
+		searchPromise = _runManagedExeCapture(binary, args, {
 			env: colgrepEnv(),
 			inactivityTimeoutMs: INIT_STALL_MS,
 			onInactivityCheck: makeIndexProgressProbe(opts.workspace),
@@ -16986,14 +17171,24 @@ function buildSnippet(unit) {
 	const sig = typeof unit.signature === "string" ? unit.signature.trim() : "";
 	const code = typeof unit.code === "string" ? unit.code : "";
 	if (!code) return sig;
-	const body = code.split("\n").slice(0, 6).join("\n");
-	const snippet = sig && !body.startsWith(sig) ? `${sig}\n${body}` : body;
+	const lines = code.split("\n");
+	const body = lines.slice(0, 6).join("\n");
+	const firstBodyLine = lines[0]?.trim() ?? "";
+	const snippet = sig && firstBodyLine !== sig ? `${sig}\n${body}` : body;
 	return snippet.length > 600 ? snippet.slice(0, 600) + "…" : snippet;
 }
+function stripExtendedPathPrefix(value) {
+	if (/^\\\\\?\\UNC\\/i.test(value)) return `\\\\${value.slice(8)}`;
+	if (/^\\\\\?\\[a-z]:\\/i.test(value)) return value.slice(4);
+	return value;
+}
 function relativize(file, workspace, workspaceReal) {
-	for (const base of [workspace, workspaceReal]) try {
-		const rel = nodePath.relative(base, file);
-		if (rel && !rel.startsWith("..") && !nodePath.isAbsolute(rel)) return rel;
+	const normalizedFile = stripExtendedPathPrefix(file);
+	for (const rawBase of [workspace, workspaceReal]) try {
+		const base = stripExtendedPathPrefix(rawBase);
+		const flavor = /^[a-z]:[\\/]/i.test(base) || base.startsWith("\\\\") ? nodePath.win32 : nodePath;
+		const rel = flavor.relative(base, normalizedFile);
+		if (rel && !rel.startsWith("..") && !flavor.isAbsolute(rel)) return rel;
 	} catch {}
 	return file;
 }
@@ -17020,9 +17215,31 @@ function clampLimit(limit) {
 function kickBackgroundInit(workspace) {
 	if (isInitInFlight(workspace)) return;
 	if (!tryClaimInit(workspace)) return;
-	runInit(workspace).catch((err) => {
-		consola.debug("colbert: background init failed:", err);
+	const key = nodePath.resolve(workspace);
+	const promise = runInit(workspace).catch(async (err) => {
+		releaseInit(workspace);
+		consola.error("colbert: background init failed:", err);
+		const prior = await readColbertMeta(workspace);
+		await writeColbertMeta({
+			workspace,
+			model: prior?.model ?? MODEL_ID,
+			modelRev: prior?.modelRev ?? MODEL_REVISION,
+			binarySha: colgrepBinAsset()?.sha256,
+			ortSha: ortLibAsset()?.sha256,
+			status: "failed",
+			failureClass: "launch",
+			failedAttempts: (prior?.failedAttempts ?? 0) + 1,
+			lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			lastIndexedHead: prior?.lastIndexedHead,
+			lastIndexedDirty: prior?.lastIndexedDirty,
+			ownerInstanceId: getColbertInstanceUuid()
+		}).catch((writeErr) => {
+			consola.error("colbert: failed to record background init failure:", writeErr);
+		});
+	}).finally(() => {
+		_initPromises.delete(key);
 	});
+	_initPromises.set(key, promise);
 }
 /**
 * Whether the STARTUP auto-kick should fire for a workspace. Skips a build
@@ -17035,25 +17252,72 @@ function kickBackgroundInit(workspace) {
 async function startupKickAllowed(workspace) {
 	const meta = await readColbertMeta(workspace);
 	if (!meta || meta.status !== "failed") return true;
-	if ((meta.failedAttempts ?? 0) >= MAX_FAILED_ATTEMPTS) return false;
+	const cap = meta.failureClass === "stuck" || meta.failureClass === "corrupt" ? 2 : MAX_FAILED_ATTEMPTS;
+	if ((meta.failedAttempts ?? 0) >= cap) return false;
 	if (meta.failureClass === "stuck") return false;
 	return true;
 }
+/**
+* Encoding sessions colgrep may run in parallel: 25% of the machine's
+* threads, never fewer than 2.
+*
+* colgrep defaults this to the FULL CPU count, so a background index build
+* saturates the machine — the exact opposite of what a background build
+* should do during an interactive agent session (the proxy even holds a
+* keep-awake assertion so those sessions run long and unattended). The floor
+* of 2 keeps a 1- to 7-thread box from dropping to a single session and
+* taking proportionally forever.
+*
+* Override with `GH_ROUTER_COLBERT_PARALLEL` (a positive integer).
+*/
+function colbertParallelSessions() {
+	const raw = Number(process$1.env.GH_ROUTER_COLBERT_PARALLEL);
+	if (Number.isSafeInteger(raw) && raw > 0) return raw;
+	const threads = os.availableParallelism?.() ?? os.cpus?.().length ?? 4;
+	return Math.max(2, Math.floor(threads * .25));
+}
+/**
+* Persist the parallelism cap into the router-owned colgrep config.
+*
+* `--parallel` exists only on the `settings` subcommand — there is no
+* per-run flag and no env var. It writes `parallel_sessions` to
+* `<COLGREP_DATA_DIR>/../config.json`, which for us is
+* `<APP_DIR>/colbert/config.json`: router-owned, and NOT the user's own
+* colgrep config (verified — after we write ours, a plain `colgrep
+* settings` with no COLGREP_DATA_DIR still reports `auto`).
+*
+* Best-effort: failing here means colgrep encodes at its default (all
+* threads), which is greedy but not incorrect, so it must never block a
+* build.
+*/
+async function applyParallelismCap(binary) {
+	const sessions$1 = colbertParallelSessions();
+	try {
+		await _runManagedExeCapture(binary, [
+			"settings",
+			"--parallel",
+			String(sessions$1)
+		], {
+			env: colgrepEnv(),
+			timeoutMs: 3e4,
+			maxStdoutBytes: MAX_STDOUT_BYTES
+		});
+	} catch (err) {
+		consola.debug("colbert: could not cap colgrep parallelism:", err);
+	}
+}
 async function runInit(workspace) {
 	const binary = colgrepBinaryPath();
-	if (!existsSync(binary)) {
-		releaseInit(workspace);
-		return;
-	}
-	if (!existsSync(colbertOrtDylibPath())) {
-		releaseInit(workspace);
-		return;
-	}
+	if (!existsSync(binary)) throw new Error("colgrep binary is missing");
+	if (!existsSync(colbertOrtDylibPath())) throw new Error("ColBERT ONNX runtime is missing");
+	await applyParallelismCap(binary);
 	const prior = await readColbertMeta(workspace);
 	const baseMeta = {
 		workspace,
 		model: MODEL_ID,
 		modelRev: MODEL_REVISION,
+		binarySha: colgrepBinAsset()?.sha256,
+		ortSha: ortLibAsset()?.sha256,
 		status: "building",
 		buildPid: void 0,
 		ownerInstanceId: getColbertInstanceUuid(),
@@ -17075,7 +17339,7 @@ async function runInit(workspace) {
 		"never",
 		"--force-cpu",
 		"--model",
-		colbertModelDir(),
+		canonicalColbertModelDir(),
 		workspace
 	];
 	const onInactivityCheck = makeIndexProgressProbe(workspace);
@@ -17083,7 +17347,7 @@ async function runInit(workspace) {
 	let ok$3 = false;
 	let failureClass;
 	try {
-		const res = await runManagedExeCapture(binary, args, {
+		const res = await _runManagedExeCapture(binary, args, {
 			env: colgrepEnv(),
 			timeoutMs: INIT_TIMEOUT_MS,
 			inactivityTimeoutMs: INIT_STALL_MS,
@@ -17098,10 +17362,18 @@ async function runInit(workspace) {
 			}
 		});
 		ok$3 = !res.stalled && !res.timedOut && res.code === 0;
-		if (!ok$3) failureClass = res.stalled || res.timedOut ? "stuck" : "error";
-	} catch {
+		if (ok$3) {
+			const projectDir = await colbertProjectDir(workspace);
+			ok$3 = projectDir !== null && validateIndexIntegrity(nodePath.join(projectDir, "index")).verdict === "coherent";
+			if (!ok$3) {
+				failureClass = "corrupt";
+				if (projectDir) await quarantineProjectDir(projectDir);
+			}
+		} else failureClass = res.stalled || res.timedOut ? "stuck" : "error";
+	} catch (err) {
 		ok$3 = false;
 		failureClass = "launch";
+		consola.error("colbert: init failed to launch:", err);
 	} finally {
 		releaseInit(workspace);
 	}
@@ -17204,8 +17476,10 @@ function lexicalSearchCodeMode(mode) {
 * it both levers: retry `mode:"semantic"` shortly (the index is self-healing
 * in the background) OR re-query now with specific symbol/keyword terms.
 */
+const FALLBACK_GUIDANCE_MARKER = "retry mode:\"semantic\"";
+const FALLBACK_GUIDANCE = `${FALLBACK_GUIDANCE_MARKER} shortly, or re-query now with specific symbol/keyword terms`;
 function fallbackNoticeFor(status) {
-	const tail = "retry mode:\"semantic\" shortly, or re-query now with specific symbol/keyword terms";
+	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}`;
@@ -17224,6 +17498,38 @@ function joinNotice(primary, secondary) {
 	if (primary && secondary) return `${primary} (${secondary})`;
 	return primary || secondary || void 0;
 }
+/** Preserve runner-specific context while guaranteeing actionable guidance once. */
+function semanticFallbackNotice(sem) {
+	if (!sem.notice) return fallbackNoticeFor(sem.status);
+	if (sem.notice.includes(FALLBACK_GUIDANCE_MARKER)) return sem.notice;
+	return `${sem.notice} — ${FALLBACK_GUIDANCE}`;
+}
+async function outlinesForSemanticResults(input, results, signal) {
+	if (input.summary === false) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const files = [];
+	for (const result of results) {
+		if (seen.has(result.file)) continue;
+		seen.add(result.file);
+		files.push(result.file);
+		if (files.length >= 10) break;
+	}
+	const outlines = [];
+	const deadline = Date.now() + 2e3;
+	const workspace = nodePath.resolve(input.workspace);
+	for (const file of files) {
+		if (signal?.aborted || Date.now() > deadline) break;
+		const abs = nodePath.resolve(workspace, file);
+		const rel = nodePath.relative(workspace, abs);
+		if (!rel || rel.startsWith("..") || nodePath.isAbsolute(rel)) continue;
+		const outlined = await outlineFile(abs, signal);
+		outlines.push({
+			file,
+			outline: outlined.outline
+		});
+	}
+	return outlines;
+}
 async function runLexical(input, mode, source, signal) {
 	const isAst = mode === "ast";
 	const resp = await searchCode({
@@ -17285,22 +17591,26 @@ async function runUnifiedCodeSearch(input, signal) {
 			notice: joinNotice(r$1.notice, "semantic search errored; returned lexical results")
 		};
 	}
-	if (sem.status === "ready") return {
-		source: "semantic",
-		results: (sem.results ?? []).map((r$1) => ({
+	if (sem.status === "ready") {
+		const results = (sem.results ?? []).map((r$1) => ({
 			file: r$1.file,
 			line: r$1.line,
 			snippet: r$1.snippet,
 			...r$1.endLine !== void 0 ? { endLine: r$1.endLine } : {},
 			...r$1.name !== void 0 ? { name: r$1.name } : {},
 			...r$1.score !== void 0 ? { score: r$1.score } : {}
-		})),
-		...sem.notice ? { notice: sem.notice } : {}
-	};
+		}));
+		return {
+			source: "semantic",
+			results,
+			outlines: await outlinesForSemanticResults(input, results, signal),
+			...sem.notice ? { notice: sem.notice } : {}
+		};
+	}
 	const r = await runLexical(input, "lexical", "lexical-fallback", signal);
 	return {
 		...r,
-		notice: joinNotice(r.notice, fallbackNoticeFor(sem.status))
+		notice: joinNotice(r.notice, semanticFallbackNotice(sem))
 	};
 }
 
@@ -33901,5 +34211,5 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 }
 
 //#endregion
-export { searchWeb as $, UPSTREAM_INACTIVITY_TIMEOUT_MS as $t, trustRepo as A, createResponses as At, TEST_DEFAULT_MODEL as B, CONDENSED_OPERATING_SEQUENCE as Bt, fileLastPromptStore as C, copilotHeaders as Cn, shimDefaultsToXhigh as Ct, repoRoot as D, assembleResponsesPayload as Dt, repoFingerprint as E, getTokenCount as Et, EXPLORE_DEFAULT_MODEL as F, provisionBrowserAssets as Ft, buildEnv as G, buildWorkspaceHeaderJson as Gt, resolveModeDefaults as H, shouldUseInsecureTls as Ht, EXPLORE_DEFAULT_THINKING as I, hasSupportedBrowserInstalled as It, toolbeltEnabled as J, DEFAULT_CLAUDE_MODEL_FALLBACKS as Jt, availableToolCommands as K, collapsePathKeys as Kt, IMPLEMENT_DEFAULT_MODEL as L, provisionAndIndexColbert as Lt, resolveSealedGate as M, MAX_RESPONSE_BODY_BYTES as Mt, BROWSE_DEFAULT_MODEL as N, readResponseBodyCapped as Nt, stopGateEnabledForRepo as O, resolveMcpToolTimeoutMs as Ot, DEFAULT_MODEL as P, parseJsonOrDiagnose as Pt, assetFor as Q, UPSTREAM_FETCH_TIMEOUT_MS as Qt, PLAN_DEFAULT_MODEL as R, extractTarGzMember as Rt, fileFindingsStore as S, copilotBaseUrl as Sn, workerToolsEnabled as St, isSubagentContext as T, state as Tn, createMessages as Tt, resolveWorkerRunOpts as U, ArtifactClient as Ut, appendPlanReminder as V, DEFINITION_OF_GREATNESS as Vt, runWorkerAgent as W, buildWorkspaceHeaderHelperCommand as Wt, vscodeRipgrepPath as X, DEFAULT_CODEX_MODEL_FALLBACKS as Xt, toolbeltSkipSet as Y, DEFAULT_CODEX_MODEL as Yt, TOOLBELT_TOOLS$1 as Z, DEFAULT_PORT as Zt, stopGateDisabled as _, getGitHubUser as _n, browserToolsEnabled as _t, buildPeerAwarenessSnippet as a, setupGitHubAgentToken as an, buildAnthropicErrorEvent as at, stopReviewEnabled as b, forwardError as bn, nativeSubagentModel as bt, personasFor as c, cacheCopilotVersion as cn, logStreamError as ct, buildStopHookCommand as d, filterBetaHeader as dn, handleMcpDelete as dt, generateRandomPort as en, ADVISOR_INTERNAL_TOOL_NAME as et, captureLaunchBaseline as f, isNullish as fn, handleMcpPost as ft, launchBaselineKey as g, getModels as gn, browserCompoundToolsEnabled as gt, injectStopHookIntoSettingsFile as h, sleep as hn, browseAgentEnabled as ht, buildAgentPrompt as i, setupCopilotToken as in, isAdvisorRequested as it, liveExec as j, createChatCompletions as jt, stopReviewStateDir as k, pickEndpoint as kt, buildArtifactOpenHookCommand as l, cacheModels as ln, readIteratorWithTimeout as lt, fileBlockBudget as m, resolveModel as mn, artifactToolsEnabled as mt, MCP_GROUPS as n, getPackageVersion as nn, buildAdvisorStream as nt, buildPeerAwarenessSummary as o, setupGitHubToken as on, buildOpenAIErrorEvent as ot, decideStopHook as p, resolveCodexModel as pn, agentToolsEnabled as pt, buildToolbeltAwareness as q, toolbeltPathOverride as qt, assertMcpToolSurfaceConsistent as r, withInstallLock as rn, injectAdvisorTool as rt, enumerateInjectedMcpToolNames as s, tryRefreshAndRetry as sn, isControllerClosedError as st, GROUP_META as t, pickClaudeDefault as tn, ADVISOR_TOOL_INSTRUCTIONS as tt, buildSessionBindHookCommand as u, cacheVSCodeVersion as un, relayAnthropicStream as ut, stopGateId as v, fetchWithTransientRetry as vn, fleetToolsEnabled as vt, fileReviewDebounce as w, githubHeaders as wn, countTokens as wt, fileBaselineStore as x, GITHUB_API_BASE_URL as xn, standInToolEnabled as xt, stopGatePlanMode as y, HTTPError as yn, geminiAvailable as yt, REVIEW_DEFAULT_MODEL as z, extractZipMember as zt };
-//# sourceMappingURL=peer-mcp-personas-A6PytLD6.js.map
+export { searchWeb as $, UPSTREAM_FETCH_TIMEOUT_MS as $t, trustRepo as A, createResponses as At, TEST_DEFAULT_MODEL as B, warmTreeSitterPool as Bt, fileLastPromptStore as C, copilotBaseUrl as Cn, shimDefaultsToXhigh as Ct, repoRoot as D, assembleResponsesPayload as Dt, repoFingerprint as E, state as En, getTokenCount as Et, EXPLORE_DEFAULT_MODEL as F, provisionBrowserAssets as Ft, buildEnv as G, buildWorkspaceHeaderHelperCommand as Gt, resolveModeDefaults as H, DEFINITION_OF_GREATNESS as Ht, EXPLORE_DEFAULT_THINKING as I, hasSupportedBrowserInstalled as It, toolbeltEnabled as J, toolbeltPathOverride as Jt, availableToolCommands as K, buildWorkspaceHeaderJson as Kt, IMPLEMENT_DEFAULT_MODEL as L, provisionAndIndexColbert as Lt, resolveSealedGate as M, MAX_RESPONSE_BODY_BYTES as Mt, BROWSE_DEFAULT_MODEL as N, readResponseBodyCapped as Nt, stopGateEnabledForRepo as O, resolveMcpToolTimeoutMs as Ot, DEFAULT_MODEL as P, parseJsonOrDiagnose as Pt, assetFor as Q, DEFAULT_PORT as Qt, PLAN_DEFAULT_MODEL as R, extractTarGzMember as Rt, fileFindingsStore as S, GITHUB_API_BASE_URL as Sn, workerToolsEnabled as St, isSubagentContext as T, githubHeaders as Tn, createMessages as Tt, resolveWorkerRunOpts as U, shouldUseInsecureTls as Ut, appendPlanReminder as V, CONDENSED_OPERATING_SEQUENCE as Vt, runWorkerAgent as W, ArtifactClient as Wt, vscodeRipgrepPath as X, DEFAULT_CODEX_MODEL as Xt, toolbeltSkipSet as Y, DEFAULT_CLAUDE_MODEL_FALLBACKS as Yt, TOOLBELT_TOOLS$1 as Z, DEFAULT_CODEX_MODEL_FALLBACKS as Zt, stopGateDisabled as _, getModels as _n, browserToolsEnabled as _t, buildPeerAwarenessSnippet as a, setupCopilotToken as an, buildAnthropicErrorEvent as at, stopReviewEnabled as b, HTTPError as bn, nativeSubagentModel as bt, personasFor as c, tryRefreshAndRetry as cn, logStreamError as ct, buildStopHookCommand as d, cacheVSCodeVersion as dn, handleMcpDelete as dt, UPSTREAM_INACTIVITY_TIMEOUT_MS as en, ADVISOR_INTERNAL_TOOL_NAME as et, captureLaunchBaseline as f, filterBetaHeader as fn, handleMcpPost as ft, launchBaselineKey as g, sleep as gn, browserCompoundToolsEnabled as gt, injectStopHookIntoSettingsFile as h, resolveModel as hn, browseAgentEnabled as ht, buildAgentPrompt as i, withInstallLock as in, isAdvisorRequested as it, liveExec as j, createChatCompletions as jt, stopReviewStateDir as k, pickEndpoint as kt, buildArtifactOpenHookCommand as l, cacheCopilotVersion as ln, readIteratorWithTimeout as lt, fileBlockBudget as m, resolveCodexModel as mn, artifactToolsEnabled as mt, MCP_GROUPS as n, pickClaudeDefault as nn, buildAdvisorStream as nt, buildPeerAwarenessSummary as o, setupGitHubAgentToken as on, buildOpenAIErrorEvent as ot, decideStopHook as p, isNullish as pn, agentToolsEnabled as pt, buildToolbeltAwareness as q, collapsePathKeys as qt, assertMcpToolSurfaceConsistent as r, getPackageVersion as rn, injectAdvisorTool as rt, enumerateInjectedMcpToolNames as s, setupGitHubToken as sn, isControllerClosedError as st, GROUP_META as t, generateRandomPort as tn, ADVISOR_TOOL_INSTRUCTIONS as tt, buildSessionBindHookCommand as u, cacheModels as un, relayAnthropicStream as ut, stopGateId as v, getGitHubUser as vn, fleetToolsEnabled as vt, fileReviewDebounce as w, copilotHeaders as wn, countTokens as wt, fileBaselineStore as x, forwardError as xn, standInToolEnabled as xt, stopGatePlanMode as y, fetchWithTransientRetry as yn, geminiAvailable as yt, REVIEW_DEFAULT_MODEL as z, extractZipMember as zt };
+//# sourceMappingURL=peer-mcp-personas-BKwMCOsl.js.map