@diegopetrucci/pi-librarian 0.1.4 → 0.1.6

package/README.md

@@ -1,9 +1,11 @@
 # librarian
 
-A pi GitHub research scout inspired by `pi-librarian`, with a local checkout cache enabled by default.
+A pi GitHub research scout inspired by `pi-librarian`, with a local checkout cache disabled by default.
 
 When the `librarian` tool runs, it can cache/reuse repository checkouts locally. Use `/librarian-cache off` to force GitHub API/search and temporary fetched files only, or `/librarian-cache on` to re-enable cached local checkouts.
 
+The internal librarian subagent uses a fast auto-selected model by default, requests `low` thinking, and prompts its scout to batch independent GitHub probes in parallel. Use `/librarian-config` to set a persistent internal model or thinking-level preference.
+
 ## Install
 
 ### Standalone npm package
@@ -35,8 +37,9 @@ Then reload pi:
 - Tool name: `librarian`
 - Uses a restricted subagent with `bash` and `read`
 - Uses `gh` for GitHub search/API access
-- Uses cached local checkouts by default
+- Uses cached local checkouts only when enabled
 - Toggle cache behavior for future calls with `/librarian-cache on | off | toggle | status`
+- Configure internal subagent defaults with `/librarian-config status | model <provider/model|auto> | thinking <off|minimal|low|medium|high|xhigh|auto> | clear [all|model|thinking]`
 - Cached repos are removed lazily after 7 days without use
 
 ## Commands
@@ -48,7 +51,15 @@ Then reload pi:
 /librarian-cache toggle
 ```
 
-The command works in interactive mode, RPC mode, and print/JSON mode. It writes a global preference to `~/.pi/agent/extensions/librarian.json`, so separate non-UI invocations use the same setting. In non-UI modes, command feedback is written to stderr so stdout remains usable for normal output or JSON events.
+```text
+/librarian-config status
+/librarian-config model auto
+/librarian-config model anthropic/claude-haiku-4-5:medium
+/librarian-config thinking low
+/librarian-config clear model
+```
+
+The commands work in interactive mode, RPC mode, and print/JSON mode. They write global preferences to `~/.pi/agent/extensions/librarian.json`, so separate non-UI invocations use the same settings. In non-UI modes, command feedback is written to stderr so stdout remains usable for normal output or JSON events.
 
 ## Cache location
 

package/index.ts

@@ -30,8 +30,22 @@ const CACHE_CONFIG_FILE = "librarian.json";
 type LibrarianStatus = "running" | "done" | "error" | "aborted";
 
 type CacheMode = "disabled" | "enabled";
+type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 
-const DEFAULT_CACHE_MODE: CacheMode = "enabled";
+const DEFAULT_CACHE_MODE: CacheMode = "disabled";
+const DEFAULT_THINKING_LEVEL: ThinkingLevel = "low";
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+const PREFERRED_FAST_MODEL_PATTERNS = [
+	/\bgpt[-_. ]?5\.5(?:[-_. ].*)?\b(?:mini|nano|fast|lite)\b/,
+	/\bgpt[-_. ]?5(?:[-_. ].*)?\b(?:mini|nano|fast|lite)\b/,
+	/\bgpt[-_. ]?4(?:\.1|o)?(?:[-_. ].*)?\b(?:mini|nano)\b/,
+	/\bgemini\b.*\b(?:flash|flash-lite|lite)\b/,
+	/\bclaude\b.*\bhaiku\b/,
+	/\b(?:mistral|codestral)\b.*\b(?:small|mini|lite)\b/,
+];
+
+const HEAVY_MODEL_PATTERN = /\b(?:opus|pro|ultra|max)\b/;
 
 type ToolCall = {
 	id: string;
@@ -51,10 +65,20 @@ type CacheDetails = {
 	decisionReason: string;
 };
 
+type LibrarianModelDetails = {
+	modelRef: string;
+	modelId: string;
+	provider: string;
+	thinkingLevel: ThinkingLevel;
+	autoSelected: boolean;
+	selectionReason: string;
+};
+
 type LibrarianDetails = {
 	status: LibrarianStatus;
 	workspace: string;
 	cache: CacheDetails;
+	model: LibrarianModelDetails;
 	turns: number;
 	toolCalls: ToolCall[];
 	startedAt: number;
@@ -91,6 +115,16 @@ const LibrarianParams = Type.Object({
 			default: DEFAULT_MAX_SEARCH_RESULTS,
 		}),
 	),
+	model: Type.Optional(
+		Type.String({
+			description: "Optional model override for the internal librarian subagent. Use provider/model or auto.",
+		}),
+	),
+	thinkingLevel: Type.Optional(
+		Type.String({
+			description: `Optional thinking override for the internal librarian subagent (${THINKING_LEVELS.join(" | ")}). Default ${DEFAULT_THINKING_LEVEL}.`,
+		}),
+	),
 });
 
 function asStringArray(value: unknown, maxItems = 30): string[] {
@@ -259,6 +293,12 @@ function getCacheConfigPath(): string {
 	return path.join(getAgentDir(), "extensions", CACHE_CONFIG_FILE);
 }
 
+type LibrarianPreferences = {
+	cacheMode: CacheMode;
+	model?: string;
+	thinkingLevel: ThinkingLevel;
+};
+
 function parseCacheMode(value: unknown): CacheMode | undefined {
 	if (typeof value === "string") {
 		const normalized = value.trim().toLowerCase();
@@ -270,31 +310,74 @@ function parseCacheMode(value: unknown): CacheMode | undefined {
 	return undefined;
 }
 
-async function readCachePreference(): Promise<CacheMode> {
+function parseThinkingLevel(value: unknown): ThinkingLevel | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	return (THINKING_LEVELS as readonly string[]).includes(normalized) ? (normalized as ThinkingLevel) : undefined;
+}
+
+function normalizeModelPreference(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	const normalized = trimmed.toLowerCase();
+	if (!trimmed || normalized === "auto" || normalized === "current") return undefined;
+	return trimmed;
+}
+
+function parseModelPreference(value: unknown): { model?: string; thinkingLevel?: ThinkingLevel } {
+	const model = normalizeModelPreference(value);
+	if (!model) return {};
+	const match = model.match(/^(.*):(off|minimal|low|medium|high|xhigh)$/i);
+	if (!match?.[1]) return { model };
+	const baseModel = match[1].trim();
+	if (!baseModel || baseModel.toLowerCase() === "auto" || baseModel.toLowerCase() === "current") {
+		return { thinkingLevel: parseThinkingLevel(match[2]) };
+	}
+	return { model: baseModel, thinkingLevel: parseThinkingLevel(match[2]) };
+}
+
+async function readLibrarianPreferences(): Promise<LibrarianPreferences> {
 	try {
 		const raw = await fs.readFile(getCacheConfigPath(), "utf8");
 		const parsed = JSON.parse(raw) as {
 			cacheMode?: unknown;
 			cacheEnabled?: unknown;
 			cache?: { mode?: unknown; enabled?: unknown };
+			model?: unknown;
+			defaultModel?: unknown;
+			thinkingLevel?: unknown;
+			defaultThinkingLevel?: unknown;
+		};
+		return {
+			cacheMode:
+				parseCacheMode(parsed.cacheMode) ??
+				parseCacheMode(parsed.cache?.mode) ??
+				parseCacheMode(parsed.cacheEnabled) ??
+				parseCacheMode(parsed.cache?.enabled) ??
+				DEFAULT_CACHE_MODE,
+			model: parseModelPreference(parsed.model).model ?? parseModelPreference(parsed.defaultModel).model,
+			thinkingLevel:
+				parseThinkingLevel(parsed.thinkingLevel) ??
+				parseThinkingLevel(parsed.defaultThinkingLevel) ??
+				parseModelPreference(parsed.model).thinkingLevel ??
+				parseModelPreference(parsed.defaultModel).thinkingLevel ??
+				DEFAULT_THINKING_LEVEL,
 		};
-		return (
-			parseCacheMode(parsed.cacheMode) ??
-			parseCacheMode(parsed.cache?.mode) ??
-			parseCacheMode(parsed.cacheEnabled) ??
-			parseCacheMode(parsed.cache?.enabled) ??
-			DEFAULT_CACHE_MODE
-		);
 	} catch (error) {
-		return (error as NodeJS.ErrnoException).code === "ENOENT" ? DEFAULT_CACHE_MODE : "disabled";
+		return {
+			cacheMode: (error as NodeJS.ErrnoException).code === "ENOENT" ? DEFAULT_CACHE_MODE : "disabled",
+			thinkingLevel: DEFAULT_THINKING_LEVEL,
+		};
 	}
 }
 
-async function writeCachePreference(preference: CacheMode): Promise<void> {
+async function writeLibrarianPreferences(preferences: LibrarianPreferences): Promise<void> {
 	const configPath = getCacheConfigPath();
 	const config = {
-		cacheMode: preference,
-		cacheEnabled: preference === "enabled",
+		cacheMode: preferences.cacheMode,
+		cacheEnabled: preferences.cacheMode === "enabled",
+		...(preferences.model ? { model: preferences.model } : {}),
+		thinkingLevel: preferences.thinkingLevel,
 		updatedAt: new Date().toISOString(),
 	};
 
@@ -302,6 +385,11 @@ async function writeCachePreference(preference: CacheMode): Promise<void> {
 	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
 }
 
+async function writeCachePreference(preference: CacheMode): Promise<void> {
+	const preferences = await readLibrarianPreferences();
+	await writeLibrarianPreferences({ ...preferences, cacheMode: preference });
+}
+
 function resolveCacheDecision(preference: CacheMode): { enabled: boolean; reason: string } {
 	if (preference === "enabled") {
 		return { enabled: true, reason: "cache preference enabled; using cached local checkouts" };
@@ -314,6 +402,10 @@ function formatCachePreference(preference: CacheMode): string {
 	return preference === "enabled" ? "on" : "off";
 }
 
+function formatLibrarianPreferences(preferences: LibrarianPreferences): string {
+	return `Librarian defaults: cache=${formatCachePreference(preferences.cacheMode)}, model=${preferences.model ?? "auto"}, thinkingLevel=${preferences.thinkingLevel}. Config: ${getCacheConfigPath()}`;
+}
+
 function notifyCommand(ctx: ExtensionContext, message: string, type: "info" | "warning" | "error" = "info"): void {
 	if (ctx.hasUI) {
 		ctx.ui.notify(message, type);
@@ -323,6 +415,117 @@ function notifyCommand(ctx: ExtensionContext, message: string, type: "info" | "w
 	console.error(message);
 }
 
+function modelRef(model: any): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function modelCostScore(model: any): number {
+	const cost = model.cost ?? {};
+	const input = typeof cost.input === "number" ? cost.input : 0;
+	const output = typeof cost.output === "number" ? cost.output : 0;
+	return input + output;
+}
+
+function rankLibrarianModel(model: any): number {
+	const text = `${model.id ?? ""} ${model.name ?? ""}`.toLowerCase();
+	let score = modelCostScore(model) * 1_000_000;
+	if (model.reasoning) score += 50;
+	if (/\b(?:mini|nano|haiku|flash|lite|small|fast|instant)\b/.test(text)) score -= 10;
+	if (HEAVY_MODEL_PATTERN.test(text)) score += 1_000;
+	if ((model.contextWindow ?? 0) < 32_000) score += 100;
+	return score;
+}
+
+function isPreferredFastLibrarianModel(model: any): boolean {
+	const text = `${model.provider ?? ""} ${model.id ?? ""} ${model.name ?? ""}`.toLowerCase();
+	if (HEAVY_MODEL_PATTERN.test(text)) return false;
+	return PREFERRED_FAST_MODEL_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function rankPreferredFastLibrarianModel(model: any): number {
+	const text = `${model.provider ?? ""} ${model.id ?? ""} ${model.name ?? ""}`.toLowerCase();
+	let score = rankLibrarianModel(model);
+	const patternIndex = PREFERRED_FAST_MODEL_PATTERNS.findIndex((pattern) => pattern.test(text));
+	if (patternIndex >= 0) score += patternIndex * 100;
+	return score;
+}
+
+async function findAvailableModel(
+	ctx: { model?: any; modelRegistry: { getAvailable(): any[] | Promise<any[]> } },
+	modelPreference: string,
+): Promise<any | undefined> {
+	const available = await ctx.modelRegistry.getAvailable();
+	const trimmed = modelPreference.trim();
+	const provider = trimmed.includes("/") ? trimmed.split("/")[0].toLowerCase() : ctx.model?.provider?.toLowerCase();
+	const id = trimmed.includes("/") ? trimmed.split("/").slice(1).join("/").toLowerCase() : trimmed.toLowerCase();
+
+	const exact = available.find(
+		(model) => model.id.toLowerCase() === id && (!provider || model.provider.toLowerCase() === provider),
+	);
+	if (exact) return exact;
+
+	const partial = available.find(
+		(model) => model.id.toLowerCase().includes(id) && (!provider || model.provider.toLowerCase() === provider),
+	);
+	if (partial) return partial;
+
+	if (!provider) {
+		const uniqueById = available.filter((model) => model.id.toLowerCase() === id);
+		if (uniqueById.length === 1) return uniqueById[0];
+	}
+
+	return undefined;
+}
+
+async function selectLibrarianModel(
+	ctx: { model?: any; modelRegistry: { getAvailable(): any[] | Promise<any[]> } },
+	modelPreference: string | undefined,
+	thinkingLevel: ThinkingLevel,
+): Promise<{ model: any; details: LibrarianModelDetails }> {
+	const normalized = modelPreference?.trim();
+	if (normalized) {
+		const matched = await findAvailableModel(ctx, normalized);
+		if (matched) {
+			return {
+				model: matched,
+				details: {
+					modelRef: modelRef(matched),
+					provider: matched.provider,
+					modelId: matched.id,
+					thinkingLevel,
+					autoSelected: false,
+					selectionReason: "Using the configured librarian model.",
+				},
+			};
+		}
+	}
+
+	const available = await ctx.modelRegistry.getAvailable();
+	const preferred = available.filter(isPreferredFastLibrarianModel);
+	const winner = preferred.length > 0
+		? [...preferred].sort((a, b) => rankPreferredFastLibrarianModel(a) - rankPreferredFastLibrarianModel(b))[0]
+		: [...available].sort((a, b) => rankLibrarianModel(a) - rankLibrarianModel(b))[0];
+	if (!winner) {
+		throw new Error("No authenticated models are available for Librarian. Log in or configure an API key first.");
+	}
+
+	const fallbackText = normalized ? ` Configured model ${normalized} was unavailable, so Librarian fell back to auto-selection.` : "";
+	const selectionReason = preferred.length > 0
+		? `Selected a preferred fast Librarian model.${fallbackText}`
+		: `Selected the cheapest available model because no preferred fast Librarian model was available.${fallbackText}`;
+	return {
+		model: winner,
+		details: {
+			modelRef: modelRef(winner),
+			provider: winner.provider,
+			modelId: winner.id,
+			thinkingLevel,
+			autoSelected: true,
+			selectionReason,
+		},
+	};
+}
+
 function resolveToolPath(cwd: string, rawPath: string): string {
 	const normalized = rawPath.startsWith("@") ? rawPath.slice(1) : rawPath;
 	return path.isAbsolute(normalized) ? path.resolve(normalized) : path.resolve(cwd, normalized);
@@ -436,7 +639,7 @@ function buildSystemPrompt(options: {
 		? `\nLocal checkout cache is ENABLED for this call.\n- Cache root: ${options.cacheRoot}\n- Use checkout path pattern: ${options.cacheRoot}/github.com/<owner>/<repo>\n- Reuse an existing checkout when it has a .git directory. Fetch/prune before relying on it: git -C "$DIR" fetch --all --prune --tags --quiet\n- If missing, clone with gh repo clone "$REPO" "$DIR" (or git clone https://github.com/$REPO.git "$DIR").\n- If a ref/branch/SHA is requested, fetch it and check it out locally before citing files from that ref.\n- After using a checkout, update its cache marker: touch "$DIR/${CACHE_MARKER_FILE}"\n- Prefer local rg/read inside cached checkouts once a repo is cloned, and cite absolute cached paths with line ranges.\n- Clone only repositories that are relevant to the query; do not bulk-clone broad owner/org scopes unless necessary.`
 		: `\nLocal checkout cache is DISABLED for this call.\n- Do not clone repositories.\n- Use gh search/API/tree/contents calls and cache only necessary proof files under ${options.workspace}/repos/<owner>/<repo>/<path>.`;
 
-	return `You are Librarian, an evidence-first GitHub code scout running inside pi.\n\nUse only the available bash/read tools. Use gh, jq, rg, find/fd, ls, stat, mkdir, base64, and nl -ba for GitHub reconnaissance and numbered evidence. Use read for focused local file inspection.\n\nWorkspace: ${options.workspace}\nDefault gh search limit: ${options.maxSearchResults}\nTurn budget: ${MAX_TURNS} turns total, including your final answer. Stop searching once you have enough evidence.\n${cacheSection}\n\nNon-negotiable constraints:\n- Never treat gh search snippets as proof by themselves. Use fetched files or local checkouts for code-content claims.\n- Keep temporary workspace writes under ${options.workspace}/repos unless local checkout cache is enabled, in which case writes under the cache root are also allowed.
+	return `You are Librarian, an evidence-first GitHub code scout running inside pi.\n\nUse only the available bash/read tools. Use gh, jq, rg, find/fd, ls, stat, mkdir, base64, and nl -ba for GitHub reconnaissance and numbered evidence. Use read for focused local file inspection.\n\nWorkspace: ${options.workspace}\nDefault gh search limit: ${options.maxSearchResults}\nTurn budget: ${MAX_TURNS} turns total, including your final answer. Stop searching once you have enough evidence.\n${cacheSection}\n\nPerformance guidance:\n- Prefer fast, parallel exploration. When probes are independent, issue multiple separate tool calls in the same assistant turn instead of waiting for each result one-by-one.\n- Aim for 4-8 independent bash/read calls in an exploration turn when useful: parallel gh searches, tree probes, contents fetches, and targeted file reads.\n- Keep dependent work sequential, and avoid concurrent writes to the same file, checkout, or cache directory.\n\nNon-negotiable constraints:\n- Never treat gh search snippets as proof by themselves. Use fetched files or local checkouts for code-content claims.\n- Keep temporary workspace writes under ${options.workspace}/repos unless local checkout cache is enabled, in which case writes under the cache root are also allowed.
 - A runtime guard blocks destructive shell commands, credential/environment inspection, and reads outside the workspace/cache.\n- Never paste whole files. Use short snippets only when they clarify the evidence.\n- If evidence is partial or access fails (404/403), state the limitation clearly.\n- Do not present anything as fact unless it appeared in tool output or in a file you read.\n\nRecommended search flow:\n1. If symbols/text are known, start with gh search code and the provided repo/owner filters.\n2. If a repo is known but paths are unclear, resolve the default branch and inspect the git tree or contents API.\n3. Fetch or clone only the files/repos required to prove the answer.\n4. Use rg/read/nl -ba locally to produce stable path and line evidence.\n\nUseful gh patterns:\n- gh repo view "$REPO" --json defaultBranchRef --jq '.defaultBranchRef.name'\n- gh search code '<terms>' --json path,repository,sha,url,textMatches --limit ${options.maxSearchResults}\n- gh api "repos/$REPO/git/trees/$REF?recursive=1" > tree.json\n- gh api "repos/$REPO/contents/$FILE?ref=$REF" --jq .content | tr -d '\\n' | base64 --decode > "repos/$REPO/$FILE"\n- rg -n '<pattern>' '<local path>'\n- nl -ba '<local file>' | sed -n '10,30p'\n\nOutput format, exact order:\n## Summary\n1-3 concise sentences.\n## Locations\n- \`path\` or \`path:lineStart-lineEnd\` — what is here and why it matters; include GitHub URL when useful. If nothing relevant is found, write \`- (none)\`.\n## Evidence\n- \`path\` or \`path:lineStart-lineEnd\` — what this proves. Include concise snippets only if useful.\n## Searched\nOnly include when incomplete/not found or when the search path matters. List queries, filters, and probes used.\n## Next steps\nOptional: 1-3 narrow follow-up checks for remaining ambiguity.`;
 }
 
@@ -444,20 +647,56 @@ function buildUserPrompt(query: string, repos: string[], owners: string[], maxSe
 	return `Task: locate and cite exact GitHub code locations that answer the query.\n\nQuery: ${query}\nRepository filters: ${repos.length ? repos.join(", ") : "(none)"}\nOwner filters: ${owners.length ? owners.join(", ") : "(none)"}\nMax search results per gh search call: ${maxSearchResults}\nLocal checkout cache: ${cache.mode === "enabled" ? `enabled at ${cache.root}` : "disabled"}\nCache decision: ${cache.decisionReason}\n\nRespond directly with concise, citation-heavy findings. Always pass --limit ${maxSearchResults} to gh search code unless a narrower command is clearly better.`;
 }
 
-function extractLastAssistantText(messages: unknown[]): string {
+type AssistantLikeMessage = {
+	role?: string;
+	content?: unknown;
+	stopReason?: unknown;
+	errorMessage?: unknown;
+};
+
+function getLastAssistantMessage(messages: unknown[]): AssistantLikeMessage | undefined {
 	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i] as { role?: string; content?: unknown };
-		if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
-		const parts: string[] = [];
-		for (const part of message.content) {
-			if (part && typeof part === "object" && (part as { type?: string }).type === "text") {
-				const text = (part as { text?: unknown }).text;
-				if (typeof text === "string") parts.push(text);
-			}
+		const message = messages[i] as AssistantLikeMessage;
+		if (message?.role === "assistant") return message;
+	}
+	return undefined;
+}
+
+function extractLastAssistantText(messages: unknown[]): string {
+	const message = getLastAssistantMessage(messages);
+	if (!message || !Array.isArray(message.content)) return "";
+	const parts: string[] = [];
+	for (const part of message.content) {
+		if (part && typeof part === "object" && (part as { type?: string }).type === "text") {
+			const text = (part as { text?: unknown }).text;
+			if (typeof text === "string") parts.push(text);
 		}
-		if (parts.length) return parts.join("").trim();
 	}
-	return "";
+	return parts.join("").trim();
+}
+
+function describeNoAnswerReason(message: AssistantLikeMessage | undefined, turns: number): string {
+	if (!message) return "the internal subagent produced no assistant message";
+	if (message.stopReason === "error") {
+		const errorMessage = typeof message.errorMessage === "string" && message.errorMessage.trim()
+			? message.errorMessage.trim()
+			: "provider/model error";
+		return `the internal subagent stopped with an error: ${errorMessage}`;
+	}
+	if (message.stopReason === "aborted") return "the internal subagent was aborted before producing an answer";
+	if (turns >= MAX_TURNS) return `the internal subagent reached the ${MAX_TURNS}-turn budget without producing a final answer`;
+	const stopReason = typeof message.stopReason === "string" && message.stopReason.trim()
+		? ` (stopReason: ${message.stopReason.trim()})`
+		: "";
+	return `the internal subagent completed without final assistant text${stopReason}`;
+}
+
+function formatInternalFailure(details: LibrarianDetails, reason: string): string {
+	return [
+		`Internal librarian run failed: ${reason}.`,
+		`Diagnostics: status=${details.status}; model=${details.model.modelRef}; thinking=${details.model.thinkingLevel}; modelSelection=${details.model.autoSelected ? "auto" : "configured"}; turns=${details.turns}; toolCalls=${details.toolCalls.length}.`,
+		"No answer was produced. This is not a reliable \"no results found\" signal; retry later or configure a different Librarian model with /librarian-config.",
+	].join("\n");
 }
 
 function formatToolCall(call: ToolCall): string {
@@ -489,9 +728,119 @@ function isAbortLikeError(error: unknown): boolean {
 
 export default function librarianExtension(pi: ExtensionAPI) {
 	let cachePreference: CacheMode = DEFAULT_CACHE_MODE;
+	let modelPreference: string | undefined;
+	let thinkingPreference: ThinkingLevel = DEFAULT_THINKING_LEVEL;
 
 	pi.on("session_start", async () => {
-		cachePreference = await readCachePreference();
+		const preferences = await readLibrarianPreferences();
+		cachePreference = preferences.cacheMode;
+		modelPreference = preferences.model;
+		thinkingPreference = preferences.thinkingLevel;
+	});
+
+	const currentPreferences = (): LibrarianPreferences => ({
+		cacheMode: cachePreference,
+		...(modelPreference ? { model: modelPreference } : {}),
+		thinkingLevel: thinkingPreference,
+	});
+
+	const savePreferences = async (preferences: LibrarianPreferences): Promise<string | undefined> => {
+		cachePreference = preferences.cacheMode;
+		modelPreference = preferences.model;
+		thinkingPreference = preferences.thinkingLevel;
+		try {
+			await writeLibrarianPreferences(preferences);
+			return undefined;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return `Preference changed for this process, but could not save ${getCacheConfigPath()}: ${message}`;
+		}
+	};
+
+	pi.registerCommand("librarian-config", {
+		description: "Configure Librarian subagent model and thinking defaults",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.trim().split(/\s+/).filter(Boolean);
+			if (parts.length <= 1) {
+				const commands = ["status", "model", "thinking", "clear"];
+				const query = parts[0]?.toLowerCase() ?? "";
+				return commands.filter((command) => command.startsWith(query)).map((value) => ({ value, label: value }));
+			}
+			if (parts[0]?.toLowerCase() === "thinking") {
+				const query = parts[1]?.toLowerCase() ?? "";
+				return [...THINKING_LEVELS, "auto"].filter((level) => level.startsWith(query)).map((value) => ({ value, label: value }));
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const [command = "status", ...rest] = tokens;
+			const action = command.toLowerCase();
+
+			if (action === "status" || action === "show") {
+				notifyCommand(ctx, formatLibrarianPreferences(currentPreferences()));
+				return;
+			}
+
+			if (action === "model") {
+				const value = rest.join(" ").trim();
+				if (!value) {
+					notifyCommand(ctx, "Usage: /librarian-config model <provider/model|auto>", "warning");
+					return;
+				}
+				const normalized = value.toLowerCase();
+				if (normalized === "current" || normalized.startsWith("current:")) {
+					notifyCommand(ctx, "Librarian model=current is no longer supported. Use /librarian-config model auto or choose an explicit provider/model.", "warning");
+					return;
+				}
+				const parsedModel = parseModelPreference(value);
+				const next = normalized === "auto" || normalized === "clear" || normalized === "default"
+					? { ...currentPreferences(), model: undefined }
+					: {
+						...currentPreferences(),
+						model: parsedModel.model,
+						thinkingLevel: parsedModel.thinkingLevel ?? thinkingPreference,
+					};
+				const warning = await savePreferences(next);
+				notifyCommand(ctx, `Librarian model default updated. ${warning ?? formatLibrarianPreferences(currentPreferences())}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "thinking" || action === "think" || action === "thinking-level") {
+				const value = rest[0]?.trim().toLowerCase();
+				if (!value) {
+					notifyCommand(ctx, `Usage: /librarian-config thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				const thinkingLevel = value === "auto" || value === "clear" || value === "default"
+					? DEFAULT_THINKING_LEVEL
+					: parseThinkingLevel(value);
+				if (!thinkingLevel) {
+					notifyCommand(ctx, `Usage: /librarian-config thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				const warning = await savePreferences({ ...currentPreferences(), thinkingLevel });
+				notifyCommand(ctx, `Librarian thinking default set to ${thinkingLevel}. ${warning ?? formatLibrarianPreferences(currentPreferences())}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "clear" || action === "reset") {
+				const target = rest[0]?.trim().toLowerCase() || "all";
+				let next: LibrarianPreferences;
+				if (target === "all") next = { cacheMode: cachePreference, thinkingLevel: DEFAULT_THINKING_LEVEL };
+				else if (target === "model") next = { ...currentPreferences(), model: undefined };
+				else if (target === "thinking" || target === "thinking-level") next = { ...currentPreferences(), thinkingLevel: DEFAULT_THINKING_LEVEL };
+				else {
+					notifyCommand(ctx, "Usage: /librarian-config clear [all|model|thinking]", "warning");
+					return;
+				}
+				const warning = await savePreferences(next);
+				notifyCommand(ctx, `Librarian defaults cleared (${target}). ${warning ?? formatLibrarianPreferences(currentPreferences())}`, warning ? "warning" : "info");
+				return;
+			}
+
+			notifyCommand(ctx, "Usage: /librarian-config status | model <provider/model|auto> | thinking <off|minimal|low|medium|high|xhigh|auto> | clear [all|model|thinking]", "warning");
+		},
 	});
 
 	pi.registerCommand("librarian-cache", {
@@ -556,16 +905,24 @@ export default function librarianExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.on("tool_result", async (event) => {
+		if (event.toolName !== "librarian") return undefined;
+		const details = event.details as LibrarianDetails | undefined;
+		if (details?.status !== "error") return undefined;
+		return { isError: true };
+	});
+
 	pi.registerTool({
 		name: "librarian",
 		label: "Librarian",
 		description:
-			"GitHub research scout for coding and personal-assistant tasks. Use when the answer likely lives in GitHub repos, exact repo/path locations are unknown, or you'd otherwise do exploratory gh search/tree probes plus local rg/read inspection. Librarian uses an optional 7-day local checkout cache by default; toggle it with /librarian-cache.",
+			"GitHub research scout for coding and personal-assistant tasks. Use when the answer likely lives in GitHub repos, exact repo/path locations are unknown, or you'd otherwise do exploratory gh search/tree probes plus local rg/read inspection. Librarian uses an optional 7-day local checkout cache that is disabled by default; toggle it with /librarian-cache. Configure its internal subagent defaults with /librarian-config.",
 		promptSnippet:
-			"Research GitHub repositories with evidence-first path and line citations; local checkout cache is enabled by default and user-toggleable with /librarian-cache.",
+			"Research GitHub repositories with evidence-first path and line citations; local checkout cache is disabled by default and user-toggleable with /librarian-cache. Internal subagent defaults are user-configurable with /librarian-config and default to low thinking.",
 		promptGuidelines: [
 			"Use librarian when the answer likely requires exploratory GitHub repository search or line-cited evidence from external repos.",
 			"Do not use librarian for files already present in the current workspace unless the user asks for external GitHub research.",
+			"Use model or thinkingLevel only when the user explicitly asks for a non-default internal librarian model or thinking level.",
 		],
 		parameters: LibrarianParams,
 
@@ -573,7 +930,6 @@ export default function librarianExtension(pi: ExtensionAPI) {
 			const rawQuery = (params as { query?: unknown }).query;
 			const query = typeof rawQuery === "string" ? rawQuery.trim() : "";
 			if (!query) throw new Error("Invalid parameters: expected query to be a non-empty string.");
-			if (!ctx.model) throw new Error("Librarian needs an active pi model, but ctx.model is unavailable.");
 
 			const repos = asStringArray((params as { repos?: unknown }).repos);
 			const owners = asStringArray((params as { owners?: unknown }).owners);
@@ -583,6 +939,12 @@ export default function librarianExtension(pi: ExtensionAPI) {
 				MAX_SEARCH_RESULTS,
 				DEFAULT_MAX_SEARCH_RESULTS,
 			);
+			const explicitModel = parseModelPreference((params as { model?: unknown }).model);
+			const thinkingLevel =
+				parseThinkingLevel((params as { thinkingLevel?: unknown }).thinkingLevel) ??
+				explicitModel.thinkingLevel ??
+				thinkingPreference;
+			const selectedModel = await selectLibrarianModel(ctx, explicitModel.model ?? modelPreference, thinkingLevel);
 
 			const workspaceBase = path.join(os.tmpdir(), "pi-librarian");
 			await fs.mkdir(workspaceBase, { recursive: true });
@@ -617,6 +979,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 					cleanupErrors: cleanup.errors,
 					decisionReason: cacheDecision.reason,
 				},
+				model: selectedModel.details,
 				turns: 0,
 				toolCalls: [],
 				startedAt: Date.now(),
@@ -687,8 +1050,8 @@ export default function librarianExtension(pi: ExtensionAPI) {
 					modelRegistry: ctx.modelRegistry,
 					resourceLoader,
 					sessionManager: SessionManager.inMemory(workspace),
-					model: ctx.model,
-					thinkingLevel: pi.getThinkingLevel(),
+					model: selectedModel.model,
+					thinkingLevel,
 					tools: ["read", "bash"],
 				});
 
@@ -736,9 +1099,20 @@ export default function librarianExtension(pi: ExtensionAPI) {
 					await Promise.race([promptPromise, timeoutPromise]);
 				}
 
+				const lastAssistant = session ? getLastAssistantMessage(session.state.messages) : undefined;
 				const answer = session ? extractLastAssistantText(session.state.messages) : "";
-				lastContent = answer || (aborted ? "Aborted" : "(no output)");
-				details.status = aborted ? "aborted" : "done";
+				if (answer) {
+					lastContent = answer;
+					details.status = "done";
+				} else if (aborted) {
+					lastContent = "Aborted";
+					details.status = "aborted";
+				} else {
+					details.status = "error";
+					const reason = describeNoAnswerReason(lastAssistant, details.turns);
+					lastContent = formatInternalFailure(details, reason);
+					details.error = reason;
+				}
 				details.endedAt = Date.now();
 				emit(true);
 
@@ -807,6 +1181,10 @@ export default function librarianExtension(pi: ExtensionAPI) {
 			)}${cacheLabel}`;
 
 			const workspaceLine = `${theme.fg("muted", "workspace: ")}${theme.fg("toolOutput", details.workspace)}`;
+			const modelLine = `${theme.fg("muted", "model: ")}${theme.fg("toolOutput", details.model.modelRef)} ${theme.fg(
+				"dim",
+				`(${details.model.thinkingLevel}, ${details.model.autoSelected ? "auto" : "configured"})`,
+			)}`;
 			const cacheLine = `${theme.fg("muted", "cache: ")}${theme.fg("toolOutput", details.cache.root)} ${theme.fg(
 				"dim",
 				`(${details.cache.mode}, ${details.cache.ttlDays}d TTL, cleaned ${details.cache.cleanupDeleted})`,
@@ -822,7 +1200,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 			if (!expanded && details.toolCalls.length > 6) toolLines.unshift(theme.fg("muted", "…"));
 
 			if (status === "running") {
-				const parts = [header, workspaceLine, cacheLine];
+				const parts = [header, workspaceLine, modelLine, cacheLine];
 				if (toolLines.length) parts.push("", theme.fg("muted", "Tools:"), ...toolLines);
 				parts.push("", theme.fg("muted", "Searching GitHub…"));
 				return new Text(parts.join("\n"), 0, 0);
@@ -830,7 +1208,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 
 			if (!expanded) {
 				const previewLines = answer.split("\n").slice(0, 18);
-				const parts = [header, workspaceLine, cacheLine, "", theme.fg("toolOutput", previewLines.join("\n"))];
+				const parts = [header, workspaceLine, modelLine, cacheLine, "", theme.fg("toolOutput", previewLines.join("\n"))];
 				if (answer.split("\n").length > previewLines.length) parts.push(theme.fg("muted", "(Ctrl+O to expand)"));
 				if (toolLines.length) parts.push("", theme.fg("muted", "Tools:"), ...toolLines);
 				return new Text(parts.join("\n"), 0, 0);
@@ -839,6 +1217,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 			const container = new Container();
 			container.addChild(new Text(header, 0, 0));
 			container.addChild(new Text(workspaceLine, 0, 0));
+			container.addChild(new Text(modelLine, 0, 0));
 			container.addChild(new Text(cacheLine, 0, 0));
 			if (details.cache.cleanupErrors.length) {
 				container.addChild(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-librarian",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A pi GitHub research scout with a toggleable local repo checkout cache under the user's OS cache directory.",
   "keywords": [
     "pi-package",