github-router 0.3.219 → 0.3.233

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

@@ -1,6 +1,6 @@
-import { t as PATHS } from "./paths-BO22pMUb.js";
-import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-D-1CYr1Y.js";
-import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-bPdiXjYB.js";
+import { t as PATHS } from "./paths-ogCi3URX.js";
+import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-C5ALWmZK.js";
+import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-DR4TGEIY.js";
 import { createRequire } from "node:module";
 import consola from "consola";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
@@ -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: [],
@@ -15824,318 +15861,6 @@ function modelDirName() {
 /** Short model id used in the sidecar metadata `model` field. */
 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;
-	}
-}
-/**
-* 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 completedIndexOnDisk(workspace) {
-	const indicesDir = PATHS.COLBERT_INDICES_DIR;
-	let names;
-	try {
-		names = await fs.readdir(indicesDir);
-	} catch {
-		return false;
-	}
-	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;
-		try {
-			proj = JSON.parse(await fs.readFile(projJson, "utf8"));
-		} catch {
-			continue;
-		}
-		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) {
-	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;
-		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) {
@@ -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,7 +16324,7 @@ 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");
@@ -16620,7 +16353,7 @@ async function runSmokeTest(binaryPath, ortDylibPath, modelDir) {
 			"never",
 			"--force-cpu",
 			"--model",
-			modelDir,
+			canonicalColbertModelDir(),
 			"-y",
 			"-k",
 			"1",
@@ -16658,6 +16391,395 @@ async function runSmokeTest(binaryPath, ortDylibPath, modelDir) {
 	}
 }
 
+//#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 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 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/colbert/runner.ts
 /** Caller responsiveness budget for a search. A warm search is sub-second;
@@ -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))
 	};
 }
 
@@ -18498,7 +18808,7 @@ function logAudit$1(record) {
 		try {
 			const fs$2 = await import("node:fs/promises");
 			const path$1 = await import("node:path");
-			const { PATHS: PATHS$1 } = await import("./paths-B5k78n0d.js");
+			const { PATHS: PATHS$1 } = await import("./paths-D20MaHeo.js");
 			const dir = path$1.join(PATHS$1.APP_DIR, "browser-mcp");
 			await fs$2.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -25311,7 +25621,14 @@ async function countTokens(body, extraHeaders, callerSignal, retryTransient = fa
 */
 /** Preference-ordered OpenAI frontier reasoning models (SELECTION list). */
 const OPENAI_FRONTIER_MODELS = ["gpt-5.6-sol", "gpt-5.5"];
-/** Models whose shim DEFAULT reasoning effort is xhigh (effort POLICY set). */
+/** Models whose shim reasoning effort becomes xhigh when the operator opts in
+*  with `GH_ROUTER_FRONTIER_XHIGH_DEFAULT=1` (effort POLICY set).
+*
+*  This is opt-IN, not the default. The shim maps a client's level to the
+*  identical provider level and injects only `high` when the client sends no
+*  `thinking` block at all; forcing xhigh here would silently override the level
+*  the user chose. The set is retained so the opt-in restores the previous
+*  behavior exactly, targeting the same models it used to. */
 const XHIGH_DEFAULT_SHIM_MODELS = ["gpt-5.6-sol", "gpt-5.5"];
 /** Normalize a model id for policy comparison: strip a leading `vendor/`
 *  prefix and any trailing `[...]` decoration(s) (e.g. `[1m]`, `[1m][beta]`)
@@ -25319,7 +25636,8 @@ const XHIGH_DEFAULT_SHIM_MODELS = ["gpt-5.6-sol", "gpt-5.5"];
 function normalizeModelId(id) {
 	return (id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id).replace(/(?:\[[^\]]*\])+\s*$/, "");
 }
-/** True iff `id` (after normalization) is in the xhigh effort-policy set. */
+/** True iff `id` (after normalization) is in the xhigh effort-policy set. Only
+*  consulted when `GH_ROUTER_FRONTIER_XHIGH_DEFAULT=1` opts in. */
 function shimDefaultsToXhigh(id) {
 	return XHIGH_DEFAULT_SHIM_MODELS.includes(normalizeModelId(id));
 }
@@ -25351,21 +25669,35 @@ function geminiAvailable(source = state) {
 	return models.some((m) => /^gemini-3\..*pro/i.test(m.id));
 }
 /**
-* First available OpenAI frontier model in the live catalog (prefer
-* `gpt-5.6-sol`, fall back to `gpt-5.5`). Returns undefined when neither is
-* present. With `requireToolCalls`, only returns a model whose catalog entry
-* advertises `tool_calls`.
+* First id in `chain` that is present in the live catalog. With
+* `requireToolCalls`, skips an entry whose catalog record does not advertise
+* `tool_calls` (strict `!== true`, so absent metadata fails closed). Returns
+* undefined when the catalog is unavailable or nothing in the chain matches, so
+* every caller degrades gracefully rather than throwing on a thin catalog.
+*
+* Extracted from `resolveOpenAiFrontier` so the per-agent resolvers below share
+* one walk instead of hand-copying it. Ids are matched EXACTLY against
+* `catalog.id` — no slug translation, matching the pre-existing behavior.
 */
-function resolveOpenAiFrontier(opts) {
+function firstPresentInCatalog(chain, opts) {
 	const models = state.models?.data;
 	if (!models) return void 0;
-	for (const id of OPENAI_FRONTIER_MODELS) {
+	for (const id of chain) {
 		const found = models.find((m) => m.id === id);
 		if (!found) continue;
 		if (opts?.requireToolCalls && found.capabilities?.supports?.tool_calls !== true) continue;
 		return id;
 	}
 }
+/**
+* First available OpenAI frontier model in the live catalog (prefer
+* `gpt-5.6-sol`, fall back to `gpt-5.5`). Returns undefined when neither is
+* present. With `requireToolCalls`, only returns a model whose catalog entry
+* advertises `tool_calls`.
+*/
+function resolveOpenAiFrontier(opts) {
+	return firstPresentInCatalog(OPENAI_FRONTIER_MODELS, opts);
+}
 function standInToolEnabled() {
 	const models = state.models?.data;
 	if (!models) return false;
@@ -25374,13 +25706,44 @@ function standInToolEnabled() {
 	const hasGeminiPro = geminiAvailable();
 	return hasOpenAi && hasOpus && hasGeminiPro;
 }
-/** Return the model for the native OpenAI subagents (implementer, debugger,
-*  qa-engineer) iff it is live with tool calls. Prefers `gpt-5.6-sol`, falls
-*  back to `gpt-5.5`. One gate governs all three — they need the same frontier
-*  model. */
+/** Model for the native subagents that want the OpenAI frontier coder
+*  (`implementer`, `reviewer`) iff it is live with tool calls. Prefers
+*  `gpt-5.6-sol`, falls back to `gpt-5.5`. Absent → those agents omit their
+*  `model:` line and inherit the lead's model. */
 function nativeSubagentModel() {
 	return resolveOpenAiFrontier({ requireToolCalls: true });
 }
+/** Model for `brainstorm`. Absent → inherits the lead's model.
+*
+*  Leads with Google so the options it generates come from a third lab: the
+*  Anthropic lead is the producer and the OpenAI frontier already backs
+*  `implementer`/`reviewer`, so a same-lab brainstormer would mostly restate
+*  what the lead already thought of. */
+function brainstormModel() {
+	return firstPresentInCatalog([REVIEW_DEFAULT_MODEL, ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
+}
+/** Model for `scribe`. Absent → inherits the lead's model.
+*
+*  Leads with the mid tier: documentation is verifiable prose, not frontier
+*  reasoning. */
+function scribeModel() {
+	return firstPresentInCatalog(["gpt-5.6-terra", ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
+}
+/**
+* Model for `scout` — CHEAP TIER ONLY, with no frontier fallback on purpose.
+*
+* `scout` exists so a foreground repository lookup does not run at the lead's
+* model rates. The usual "absent → omit `model:` and inherit the lead" fallback
+* would therefore defeat the agent: on a thin or briefly-unavailable catalog it
+* would silently start answering grep-and-summarize questions on Opus, which is
+* the exact cost it was added to avoid. Returning undefined here makes the
+* caller drop the agent instead, so the lead falls back to the CLI's `Explore`
+* (same behavior as before `scout` existed) rather than to an expensive
+* impostor wearing the cheap agent's name.
+*/
+function scoutModel() {
+	return firstPresentInCatalog([EXPLORE_DEFAULT_MODEL, DEFAULT_MODEL], { requireToolCalls: true });
+}
 /**
 * Gate for the worker tools (`explore`, `review`, `implement`).
 *
@@ -32646,9 +33009,12 @@ function buildAgentPrompt(persona, opts) {
 *     of the live catalog). The raw `mcp__<workers>__*` tools are named only
 *     as the guarded plumbing the dispatchers call, never as a main-agent
 *     interface.
-*   - Always names the implementer/debugger/qa-engineer native subagents
-*     (they are injected unconditionally); the implementer-vs-`worker-implement`
-*     contrast is added only when worker tools are available.
+*   - Always names the implementer/reviewer/brainstorm/scribe native subagents
+*     (they are injected unconditionally, degrading to the lead's model rather
+*     than disappearing); `scout` is named only when `scoutAvailable` is not
+*     false, because it is dropped outright when no cheap-tier model resolves.
+*     The implementer-vs-`worker-implement` contrast is added only when worker
+*     tools are available.
 *   - Conditionally lists stand_in only when `standInAvailable`
 *     (mirrors `standInToolEnabled()`).
 *   - Conditionally lists gh-first-mate only when `agentToolsAvailable`
@@ -32680,7 +33046,7 @@ function buildPeerAwarenessSnippet(opts) {
 	const codexCliClause = opts.codexCli ? " `mcp__codex-cli__codex` dispatches to `codex-implementer` (gpt-5.3-codex with workspace-write) for end-to-end coding tasks." : "";
 	const para2Parts = [`\`mcp__${searchKey}__code\` is the one-stop code search (no extra model call). Its DEFAULT mode (or \`mode:"semantic"\`) ranks by MEANING via ColBERT over a per-workspace index, the first thing to reach for on intent/concept questions ("where is retry/backoff handled", "how does auth work"); when that index isn't ready it transparently falls back to lexical (the response \`source\` says which engine ran). Forced modes cover the rest: \`lexical\` (BM25F-ranked + tree-sitter, best for exact symbols), \`exact\`, \`regex\`, \`complete\` (exhaustive set), \`ast_pattern\`+\`ast_lang\` for multi-line AST shapes, \`scan\` for a whole-workspace symbol outline, \`multiline\` for cross-line regex. Multiple queries can run in a single turn. The index covers code-shaped files; for unstructured files (logs, \`.csv\`, \`.env*\`, config-only wiring), \`grep\`/\`glob\` still apply.`];
 	if (opts.workerToolsAvailable) para2Parts.push(`\`worker-*\` are background Agent subagents (subagent_type) that run the matching worker in its own context and deliver the result as a completion notification, so a long run never blocks the turn: \`worker-explore\` (read-only research), \`worker-review\` (reads the code to verify a change or claim), \`worker-plan\` (ordered implementation plan), \`worker-implement\` (edit/write/bash; ALWAYS runs in an isolated git worktree and returns the diff via a saved patch file; for in-place edits use the \`implementer\` subagent), \`worker-test\` (independent test author; also always worktree-isolated). The raw \`mcp__${workersKey}__*\` tools they call are guarded (a direct main-thread call is redirected to the matching agent); Workers themselves have \`code_search\`.`);
-	para2Parts.push(`Three native subagents are always available (Task): \`implementer\` (bounded implementation), \`debugger\` (reproduce + isolate a failure's root cause), and \`qa-engineer\` (review + author/run tests), each in its own context so the lead's context stays free; on gpt-5.6-sol when in the catalog, else the lead's model.`);
+	para2Parts.push(`Native subagents (Task), each in its own context so heavy work never fills yours: \`implementer\` (you know what to build), \`reviewer\` (something exists and you want it assessed, including reproducing and root-causing a failure), \`brainstorm\` (you do not yet know which approach to take)${opts.scoutAvailable === false ? "" : ", `scout` (find or understand something in the repo, cheap)"}, \`scribe\` (docs and ADRs that trail the code).`);
 	if (opts.workerToolsAvailable) para2Parts.push(`For a bounded, well-scoped implementation, prefer the \`implementer\` subagent over \`worker-implement\`; reach for \`worker-implement\` only when you specifically need git-worktree isolation, parallel variants, or a throwaway experiment.`);
 	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${orchestrateKey}__decompose\` composes an open-ended ask into a typed, VERIFIED workflow IR (a strong driver decorrelated by a cross-lab critic, so the decompose step isn't a single point of failure), and \`mcp__${orchestrateKey}__run_workflow\` executes that IR through a frozen kernel delivering max(orchestrated, baseline) over a sealed executable gate, so it never ships worse than a plain single-model run. \`mcp__${orchestrateKey}__verify_workflow\` checks an IR's floor invariants before you run it, and \`mcp__${orchestrateKey}__attest_step\` audits that a finished run's producers were each checked by a different lab. They suit non-trivial, role-separated asks; a trivial ask does not need them.`);
 	else para2Parts.push(`\`mcp__${orchestrateKey}__verify_workflow\` statically checks a workflow IR's floor invariants and \`mcp__${orchestrateKey}__attest_step\` audits a run's cross-lab lineage (the \`decompose\`/\`run_workflow\` composer + kernel need the worker backend, unavailable here).`);
@@ -33901,5 +34267,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 $, DEFAULT_CODEX_MODEL as $t, trustRepo as A, assembleResponsesPayload as At, TEST_DEFAULT_MODEL as B, provisionAndIndexColbert as Bt, fileLastPromptStore as C, HTTPError as Cn, scribeModel as Ct, repoRoot as D, copilotHeaders as Dn, countTokens as Dt, repoFingerprint as E, copilotBaseUrl as En, shimDefaultsToXhigh as Et, EXPLORE_DEFAULT_MODEL as F, MAX_RESPONSE_BODY_BYTES as Ft, buildEnv as G, DEFINITION_OF_GREATNESS as Gt, resolveModeDefaults as H, extractZipMember as Ht, EXPLORE_DEFAULT_THINKING as I, readResponseBodyCapped as It, toolbeltEnabled as J, buildWorkspaceHeaderHelperCommand as Jt, availableToolCommands as K, shouldUseInsecureTls as Kt, IMPLEMENT_DEFAULT_MODEL as L, parseJsonOrDiagnose as Lt, resolveSealedGate as M, pickEndpoint as Mt, BROWSE_DEFAULT_MODEL as N, createResponses as Nt, stopGateEnabledForRepo as O, githubHeaders as On, createMessages as Ot, DEFAULT_MODEL as P, createChatCompletions as Pt, assetFor as Q, DEFAULT_CLAUDE_MODEL_FALLBACKS as Qt, PLAN_DEFAULT_MODEL as R, provisionBrowserAssets as Rt, fileFindingsStore as S, fetchWithTransientRetry as Sn, scoutModel as St, isSubagentContext as T, GITHUB_API_BASE_URL as Tn, workerToolsEnabled as Tt, resolveWorkerRunOpts as U, warmTreeSitterPool as Ut, appendPlanReminder as V, extractTarGzMember as Vt, runWorkerAgent as W, CONDENSED_OPERATING_SEQUENCE as Wt, vscodeRipgrepPath as X, collapsePathKeys as Xt, toolbeltSkipSet as Y, buildWorkspaceHeaderJson as Yt, TOOLBELT_TOOLS$1 as Z, toolbeltPathOverride as Zt, stopGateDisabled as _, resolveCodexModel as _n, browserCompoundToolsEnabled as _t, buildPeerAwarenessSnippet as a, pickClaudeDefault as an, buildAnthropicErrorEvent as at, stopReviewEnabled as b, getModels as bn, geminiAvailable as bt, personasFor as c, setupCopilotToken as cn, logStreamError as ct, buildStopHookCommand as d, tryRefreshAndRetry as dn, handleMcpDelete as dt, DEFAULT_CODEX_MODEL_FALLBACKS as en, ADVISOR_INTERNAL_TOOL_NAME as et, captureLaunchBaseline as f, cacheCopilotVersion as fn, handleMcpPost as ft, launchBaselineKey as g, isNullish as gn, browseAgentEnabled as gt, injectStopHookIntoSettingsFile as h, filterBetaHeader as hn, brainstormModel as ht, buildAgentPrompt as i, generateRandomPort as in, isAdvisorRequested as it, liveExec as j, resolveMcpToolTimeoutMs as jt, stopReviewStateDir as k, state as kn, getTokenCount as kt, buildArtifactOpenHookCommand as l, setupGitHubAgentToken as ln, readIteratorWithTimeout as lt, fileBlockBudget as m, cacheVSCodeVersion as mn, artifactToolsEnabled as mt, MCP_GROUPS as n, UPSTREAM_FETCH_TIMEOUT_MS as nn, buildAdvisorStream as nt, buildPeerAwarenessSummary as o, getPackageVersion as on, buildOpenAIErrorEvent as ot, decideStopHook as p, cacheModels as pn, agentToolsEnabled as pt, buildToolbeltAwareness as q, ArtifactClient as qt, assertMcpToolSurfaceConsistent as r, UPSTREAM_INACTIVITY_TIMEOUT_MS as rn, injectAdvisorTool as rt, enumerateInjectedMcpToolNames as s, withInstallLock as sn, isControllerClosedError as st, GROUP_META as t, DEFAULT_PORT as tn, ADVISOR_TOOL_INSTRUCTIONS as tt, buildSessionBindHookCommand as u, setupGitHubToken as un, relayAnthropicStream as ut, stopGateId as v, resolveModel as vn, browserToolsEnabled as vt, fileReviewDebounce as w, forwardError as wn, standInToolEnabled as wt, fileBaselineStore as x, getGitHubUser as xn, nativeSubagentModel as xt, stopGatePlanMode as y, sleep as yn, fleetToolsEnabled as yt, REVIEW_DEFAULT_MODEL as z, hasSupportedBrowserInstalled as zt };
+//# sourceMappingURL=peer-mcp-personas-B-EPdjSE.js.map