@diegopetrucci/pi-extensions 0.1.39 → 0.1.42

package/README.md

@@ -9,10 +9,10 @@ A collection of [pi](https://github.com/earendil-works/pi-mono) agent extensions
 - [`context-cap`](./extensions/context-cap): Caps effective model context windows at 200k tokens by default so pi avoids the `dumb zone`; toggle temporarily with `/context-cap`.
 - [`context-inspector`](./extensions/context-inspector): Adds `/context`, a local self-contained HTML dashboard that breaks down where the current session context is going, with category overview, top offenders, and drilldown search.
 - [`dirty-repo-guard`](./extensions/dirty-repo-guard): Prompts before new sessions, session switches, or forks when the current git repo has uncommitted changes.
-- [`git-footer`](./extensions/git-footer): Standalone footer extension that replaces pi's built-in footer with a TLH-style git summary: branch, dirty counts, ahead/behind, optional PR number, session name, plus context/model status. Not auto-loaded by the collection package because it conflicts with `minimal-footer`.
+- [`git-footer`](./extensions/git-footer): Standalone extension that adds TLH-style git dirty counts, ahead/behind, and optional PR number to pi's built-in footer status area.
 - [`gnosis`](./extensions/gnosis): Exposes the `gn` repo-local knowledge base CLI as an agent tool for searching and recording durable project decisions, constraints, and intent.
 - [`inline-bash`](./extensions/inline-bash): Expands `!{command}` snippets in user prompts by running them through bash before the prompt reaches the agent.
-- [`librarian`](./extensions/librarian): Adds a GitHub research scout with a local repo checkout cache enabled by default under the OS user cache directory, toggleable with `/librarian-cache`, with cached repos expiring after 7 days of non-use.
+- [`librarian`](./extensions/librarian): Adds a GitHub research scout with a local repo checkout cache disabled by default under the OS user cache directory, toggleable with `/librarian-cache`, configurable subagent model/thinking defaults via `/librarian-config`, and cached repos expiring after 7 days of non-use.
 - [`minimal-footer`](./extensions/minimal-footer): Replaces pi's built-in footer with a minimal configurable two-line layout: branch/repo on the first line, context/model on the second, optional `DUMB ZONE`, plus OpenAI Codex 5-hour and 7-day usage when available.
 - [`notify`](./extensions/notify): Sends configurable terminal, desktop, bell, and sound notifications when pi finishes and is ready for input.
 - [`openai-fast`](./extensions/openai-fast): Adds `/fast` to enable OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4 and GPT-5.5 by injecting the priority service tier.

package/extensions/claude-fast/index.ts

@@ -167,7 +167,7 @@ function syncModelBetaHeader(ctx: ExtensionContext, state: SessionState): void {
 	const requiredBase = ctx.modelRegistry.isUsingOAuth(model) ? CLAUDE_CODE_OAUTH_BETAS : [];
 	const next = shouldEnable
 		? Array.from(new Set([...existing, ...requiredBase, FAST_BETA]))
-		: existing.filter((beta) => beta !== FAST_BETA && !CLAUDE_CODE_OAUTH_BETAS.includes(beta));
+		: existing.filter((beta) => beta !== FAST_BETA);
 
 	delete headers["Anthropic-Beta"];
 	if (next.length > 0) headers["anthropic-beta"] = next.join(",");

package/extensions/claude-fast/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-claude-fast",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A pi extension that enables Anthropic Claude Fast mode for supported Claude Opus models by injecting speed=fast.",
   "keywords": [
     "pi-package",

package/extensions/git-footer/README.md

@@ -1,14 +1,15 @@
 # git-footer
 
-A TLH-style git status footer for pi.
+A TLH-style git status add-on for pi's built-in footer.
 
-This package is standalone-only and is not auto-loaded by the `@diegopetrucci/pi-extensions` collection package because only one custom footer should win.
+This package is standalone-only and is not auto-loaded by the `@diegopetrucci/pi-extensions` collection package.
 
-It replaces pi's built-in footer with a compact two-line layout whose first line mirrors how [`the-last-harness`](https://github.com/diegopetrucci/the-last-harness) summarizes repository state:
+It keeps pi's default footer intact and adds a compact git status segment through pi's extension status API:
 
 ```text
-<repo> • <branch> • <git-status> • PR #<number> • <session-name>
-ctx <percent>% • <model> <thinking> • <extension-statuses>
+~/repo (main) • session-name
+↑12k ↓3k 44.1%/200k                      model
++2 ~1 ?3 ↑1 • PR #123
 ```
 
 Git status indicators:
@@ -20,7 +21,7 @@ Git status indicators:
 - `↑N`: commits ahead of upstream
 - `↓N`: commits behind upstream
 
-The extension polls git status in the background, caches the latest snapshot, and keeps footer rendering synchronous. It also performs a best-effort `gh pr view` lookup for the current branch; if `gh` is unavailable or the branch has no PR, the PR segment is omitted.
+The extension polls git status in the background and caches the latest snapshot. It also performs a best-effort `gh pr view` lookup for the current branch; if `gh` is unavailable or the branch has no PR, the PR segment is omitted.
 
 ## Install
 
@@ -36,6 +37,7 @@ Then reload pi:
 
 ## Notes
 
-- Replaces pi's built-in footer entirely.
-- Intended as a separate footer extension; do not enable it at the same time as another custom-footer extension such as `minimal-footer` unless you want the last-loaded footer to win.
-- `render()` never spawns subprocesses. Git and GitHub CLI lookups run on a short background interval with timeouts, and the footer reads only cached snapshots.
+- Does not replace pi's built-in footer.
+- Uses `ctx.ui.setStatus()`, so pi renders the git summary with other extension statuses.
+- The current pi extension API does not support literally appending text inside the built-in footer's first `cwd (branch)` line without replacing the footer.
+- Git and GitHub CLI lookups run on a short background interval with timeouts.

package/extensions/git-footer/index.ts

@@ -1,7 +1,5 @@
 import { spawn } from "node:child_process";
-import { basename } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
 
 type GitStatusSnapshot = {
 	branch?: string;
@@ -48,12 +46,12 @@ type GitFooterCacheOptions = {
 	gitTimeoutMs?: number;
 	ghTimeoutMs?: number;
 	onChange?: () => void;
-	onBranchChangeSource?: (callback: () => void) => () => void;
 };
 
 const BRANCH_HEAD_PREFIX = "# branch.head ";
 const BRANCH_AB_PREFIX = "# branch.ab ";
-const FOOTER_SEPARATOR = " • ";
+const STATUS_KEY = "git-footer";
+const STATUS_SEPARATOR = " • ";
 const DEFAULT_REFRESH_INTERVAL_MS = 8_000;
 const DEFAULT_GIT_TIMEOUT_MS = 1_500;
 const DEFAULT_GH_TIMEOUT_MS = 3_000;
@@ -157,21 +155,15 @@ function formatPullRequestFooterSegment(pullRequest: PullRequestSnapshot | undef
 	return undefined;
 }
 
-function formatGitFooterSegments(
+function formatGitFooterStatus(
 	status: GitStatusSnapshot | undefined,
 	pullRequest: PullRequestSnapshot | undefined,
-): string[] {
-	const segments: string[] = [];
-	const branch = typeof status?.branch === "string" ? status.branch.trim() : "";
-	if (branch) segments.push(branch);
-
-	const statusSegment = formatGitStatusFooterSegment(status);
-	if (statusSegment) segments.push(statusSegment);
-
-	const pullRequestSegment = formatPullRequestFooterSegment(pullRequest);
-	if (pullRequestSegment) segments.push(pullRequestSegment);
-
-	return segments;
+): string | undefined {
+	const parts = [
+		formatGitStatusFooterSegment(status),
+		formatPullRequestFooterSegment(pullRequest),
+	].filter((part): part is string => !!part);
+	return parts.length > 0 ? parts.join(STATUS_SEPARATOR) : undefined;
 }
 
 function parsePullRequestJson(stdout: string): PullRequestSnapshot | undefined {
@@ -307,7 +299,6 @@ class GitFooterCache {
 	private readonly inflightControllers = new Set<AbortController>();
 	private disposed = false;
 	private refreshInFlight: Promise<void> | undefined;
-	private branchChangeUnsubscribe: (() => void) | undefined;
 	private statusSnapshot: GitStatusSnapshot | undefined;
 	private pullRequestSnapshot: PullRequestSnapshot | undefined;
 	private lastSeenBranch: string | undefined;
@@ -325,12 +316,6 @@ class GitFooterCache {
 			void this.refresh();
 		}, this.refreshIntervalMs);
 		void this.refresh();
-
-		if (options.onBranchChangeSource) {
-			this.branchChangeUnsubscribe = options.onBranchChangeSource(() => {
-				void this.refresh();
-			});
-		}
 	}
 
 	getStatusSnapshot(): GitStatusSnapshot | undefined {
@@ -453,81 +438,43 @@ class GitFooterCache {
 			this.clock.clearInterval(this.intervalHandle);
 			this.intervalHandle = undefined;
 		}
-		if (this.branchChangeUnsubscribe) {
-			try {
-				this.branchChangeUnsubscribe();
-			} catch {
-				// Ignore misbehaving notifier.
-			}
-			this.branchChangeUnsubscribe = undefined;
-		}
 		for (const controller of this.inflightControllers) controller.abort();
 		this.inflightControllers.clear();
 	}
 }
 
-function composeFooterFirstLine(input: {
-	cwd: string;
-	sessionName?: string | null;
-	status?: GitStatusSnapshot;
-	pullRequest?: PullRequestSnapshot;
-}): string {
-	const segments = [input.cwd];
-	if (input.status !== undefined) {
-		segments.push(...formatGitFooterSegments(input.status, input.pullRequest));
-	}
-	if (input.sessionName) segments.push(input.sessionName);
-	return segments.join(FOOTER_SEPARATOR);
-}
+export default function (pi: ExtensionAPI) {
+	let cache: GitFooterCache | undefined;
 
-function sanitizeFooterSegment(value: string): string {
-	return value.replace(/[\r\n\t]+/g, " ").trim();
-}
+	function disposeCache(): void {
+		cache?.dispose();
+		cache = undefined;
+	}
 
-export default function (pi: ExtensionAPI) {
 	pi.on("session_start", (_event, ctx) => {
-		let cache: GitFooterCache | undefined;
-
-		ctx.ui.setFooter((tui, theme, footerData) => {
-			cache = new GitFooterCache({
-				cwd: () => ctx.cwd,
-				onChange: () => tui.requestRender(),
-				onBranchChangeSource: (callback) => footerData.onBranchChange(callback),
-			});
+		disposeCache();
+
+		const updateStatus = () => {
+			const text = formatGitFooterStatus(
+				cache?.getStatusSnapshot(),
+				cache?.getPullRequestSnapshot(),
+			);
+			ctx.ui.setStatus(STATUS_KEY, text ? ctx.ui.theme.fg("dim", text) : undefined);
+		};
 
-			return {
-				dispose() {
-					cache?.dispose();
-					cache = undefined;
-				},
-				invalidate() {},
-				render(width: number): string[] {
-					const status = cache?.getStatusSnapshot();
-					const pullRequest = cache?.getPullRequestSnapshot();
-					const firstLine = composeFooterFirstLine({
-						cwd: basename(ctx.cwd),
-						status,
-						pullRequest,
-						sessionName: pi.getSessionName(),
-					});
-
-					const usage = ctx.getContextUsage();
-					const context = usage?.percent == null ? "ctx ?" : `ctx ${usage.percent.toFixed(1)}%`;
-					const thinking = pi.getThinkingLevel();
-					const model = ctx.model?.id ?? "no-model";
-					const modelText = thinking === "off" ? model : `${model} ${thinking}`;
-					const statuses = [...footerData.getExtensionStatuses().values()]
-						.map(sanitizeFooterSegment)
-						.filter(Boolean);
-					const secondLine = [theme.fg("dim", context), theme.fg("dim", modelText), ...statuses]
-						.join(theme.fg("dim", FOOTER_SEPARATOR));
-
-					return [
-						truncateToWidth(theme.fg("dim", firstLine), width),
-						truncateToWidth(secondLine, width),
-					];
-				},
-			};
+		cache = new GitFooterCache({
+			cwd: () => ctx.cwd,
+			onChange: updateStatus,
 		});
+		updateStatus();
+	});
+
+	pi.on("turn_end", () => {
+		void cache?.refresh();
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		disposeCache();
+		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 }

package/extensions/git-footer/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-git-footer",
-  "version": "0.1.0",
-  "description": "A TLH-style git status footer for pi.",
+  "version": "0.1.1",
+  "description": "A TLH-style git status add-on for pi's built-in footer.",
   "keywords": [
     "pi-package",
     "pi",

package/extensions/librarian/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 lightweight auto-selected model by default and requests `medium` thinking. 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|current> | 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,16 @@ 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 current
+/librarian-config model anthropic/claude-haiku-4-5:medium
+/librarian-config thinking medium
+/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/extensions/librarian/index.ts

@@ -30,8 +30,11 @@ 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 = "medium";
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 
 type ToolCall = {
 	id: string;
@@ -51,10 +54,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 +104,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, auto, or current.",
+		}),
+	),
+	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 +282,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 +299,69 @@ 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();
+	if (!trimmed || trimmed.toLowerCase() === "auto") 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 };
+	return { model: match[1], 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 +369,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 +386,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 +399,115 @@ 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 (/\b(?:opus|pro|ultra|max)\b/.test(text)) score += 1_000;
+	if ((model.contextWindow ?? 0) < 32_000) score += 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?.toLowerCase() === "current") {
+		if (!ctx.model) throw new Error("Librarian model=current needs an active pi model, but ctx.model is unavailable.");
+		return {
+			model: ctx.model,
+			details: {
+				modelRef: modelRef(ctx.model),
+				provider: ctx.model.provider,
+				modelId: ctx.model.id,
+				thinkingLevel,
+				autoSelected: false,
+				selectionReason: "Using the caller's current model because librarian model=current is configured.",
+			},
+		};
+	}
+
+	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 currentProvider = ctx.model?.provider;
+	const sameProvider = currentProvider ? available.filter((model) => model.provider === currentProvider) : [];
+	const candidates = sameProvider.length > 0 ? sameProvider : available;
+	const winner = [...candidates].sort((a, b) => rankLibrarianModel(a) - rankLibrarianModel(b))[0] ?? ctx.model;
+	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.` : "";
+	return {
+		model: winner,
+		details: {
+			modelRef: modelRef(winner),
+			provider: winner.provider,
+			modelId: winner.id,
+			thinkingLevel,
+			autoSelected: true,
+			selectionReason: `Selected the cheapest available model${sameProvider.length > 0 ? " on the current provider" : ""}.${fallbackText}`,
+		},
+	};
+}
+
 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);
@@ -489,9 +674,115 @@ 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|current>", "warning");
+					return;
+				}
+				const normalized = value.toLowerCase();
+				const parsedModel = parseModelPreference(value);
+				const next = normalized === "auto" || normalized === "clear" || normalized === "default"
+					? { ...currentPreferences(), model: undefined }
+					: {
+						...currentPreferences(),
+						model: normalized === "current" ? "current" : 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|current> | thinking <off|minimal|low|medium|high|xhigh|auto> | clear [all|model|thinking]", "warning");
+		},
 	});
 
 	pi.registerCommand("librarian-cache", {
@@ -560,12 +851,13 @@ export default function librarianExtension(pi: ExtensionAPI) {
 		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 medium 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 +865,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 +874,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 +914,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 					cleanupErrors: cleanup.errors,
 					decisionReason: cacheDecision.reason,
 				},
+				model: selectedModel.details,
 				turns: 0,
 				toolCalls: [],
 				startedAt: Date.now(),
@@ -687,8 +985,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"],
 				});
 
@@ -807,6 +1105,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 +1124,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 +1132,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 +1141,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/extensions/librarian/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.39",
+  "version": "0.1.42",
   "description": "A collection of pi extensions for context management, workflow audits, review-comment triage, notifications, brrr push alerts, safety guards, GitHub research, repo-local knowledge, todos, tool rendering, and model/provider helpers.",
   "keywords": [
     "pi-package",