@diegopetrucci/pi-extensions 0.1.29 → 0.1.31

package/README.md

@@ -7,12 +7,13 @@ 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.
+- [`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 30 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.
-- [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, covers pi’s built-in providers (including Together) with hardcoded rankings, requests xhigh reasoning by default and clamps to model capabilities, and shows live status while running.
+- [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, supports persisted `/oracle` model/thinking defaults, requests xhigh reasoning by default and clamps to model capabilities, and shows live status while running.
 - [`permission-gate`](./extensions/permission-gate): Prompts for confirmation before dangerous bash commands like `rm -rf`, `sudo`, and `chmod 777`.
 - [`quiet-tools`](./extensions/quiet-tools): Renders collapsed built-in tool rows as a one-line invocation plus an expand hint without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
 - [`todo`](./extensions/todo): Adds a branch-aware `todo` tool for the agent and a `/todos` viewer for users.

package/extensions/gnosis/README.md

@@ -0,0 +1,59 @@
+# gnosis
+
+A pi extension that exposes [`gnosis`](https://github.com/skorokithakis/gnosis) as an agent tool.
+
+`gnosis` is a repo-local knowledge base for durable project context: decisions, rejected alternatives, constraints, operational lessons, and intent that are not obvious from code or docs.
+
+## What it adds
+
+- a `gnosis` tool for the agent
+- support for `plan`, `review`, `search`, `latest`, `show`, `topics`, `write`, and `reindex`
+- prompt guidance encouraging the agent to search before implementation and record only durable, non-obvious knowledge
+
+This extension intentionally does not add slash commands; it is an agent-facing wrapper around the `gn` CLI. It also intentionally omits `edit` and `rm` actions from the tool surface.
+
+## Requirements
+
+Install the `gn` CLI first:
+
+```bash
+brew install --cask skorokithakis/tap/gnosis
+```
+
+Or with Go:
+
+```bash
+go install github.com/skorokithakis/gnosis/cmd/gn@latest
+```
+
+## Install
+
+### Standalone npm package
+
+```bash
+pi install npm:@diegopetrucci/pi-gnosis
+```
+
+### Collection package
+
+```bash
+pi install npm:@diegopetrucci/pi-extensions
+```
+
+### GitHub package
+
+```bash
+pi install git:github.com/diegopetrucci/pi-extensions
+```
+
+Then reload pi:
+
+```text
+/reload
+```
+
+## Notes
+
+- The extension shells out to `gn` in the current Pi working directory.
+- Gnosis stores entries in `.gnosis/entries.jsonl` at the repo root and uses a disposable SQLite FTS5 index for search.
+- `write` mutates the repo-local gnosis knowledge base; `reindex` rebuilds the search cache.

package/extensions/gnosis/index.ts

@@ -0,0 +1,159 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	truncateTail,
+	type ExtensionAPI,
+	type ToolExecutionMode,
+} from "@earendil-works/pi-coding-agent";
+import { Type, type Static } from "typebox";
+
+const GNOSIS_TIMEOUT_MS = 30_000;
+
+const GnosisParams = Type.Object({
+	action: StringEnum(["plan", "review", "search", "latest", "show", "topics", "write", "reindex"] as const, {
+		description: "The gnosis operation to run.",
+	}),
+	query: Type.Optional(Type.String({ minLength: 1, description: "Search query for action=search. Use uppercase OR/NOT for FTS operators." })),
+	target: Type.Optional(Type.String({ minLength: 1, description: "Entry ID prefix or topic for action=show." })),
+	topics: Type.Optional(
+		Type.Array(Type.String({ minLength: 1 }), {
+			minItems: 1,
+			description: "Topics for action=write. Each normalized topic must be at least 7 chars.",
+		}),
+	),
+	text: Type.Optional(Type.String({ minLength: 1, description: "Knowledge text for action=write." })),
+	related: Type.Optional(
+		Type.Array(Type.String({ minLength: 1 }), { description: "Related entry IDs or unique prefixes for action=write." }),
+	),
+	limit: Type.Optional(Type.Integer({ minimum: 1, description: "Positive result limit for action=search or action=latest." })),
+});
+
+type GnosisParams = Static<typeof GnosisParams>;
+
+function positiveInteger(value: number | undefined, name: string): string | undefined {
+	if (value === undefined) return undefined;
+	if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer.`);
+	return String(value);
+}
+
+function requireString(value: string | undefined, name: string): string {
+	const trimmed = value?.trim();
+	if (!trimmed) throw new Error(`${name} is required.`);
+	return trimmed;
+}
+
+function buildGnosisArgs(params: GnosisParams): string[] {
+	switch (params.action) {
+		case "plan":
+			return ["help", "plan"];
+		case "review":
+			return ["help", "review"];
+		case "search": {
+			const args = ["search", requireString(params.query, "query")];
+			const limit = positiveInteger(params.limit, "limit");
+			if (limit) args.push("--limit", limit);
+			return args;
+		}
+		case "latest": {
+			const args = ["latest"];
+			const limit = positiveInteger(params.limit, "limit");
+			if (limit) args.push("--limit", limit);
+			return args;
+		}
+		case "show":
+			return ["show", requireString(params.target, "target")];
+		case "topics":
+			return ["topics"];
+		case "write": {
+			const topics = params.topics?.map((topic) => topic.trim()).filter(Boolean) ?? [];
+			if (topics.length === 0) throw new Error("topics is required for action=write.");
+			const args = ["write", topics.join(","), requireString(params.text, "text")];
+			const related = params.related?.map((id) => id.trim()).filter(Boolean) ?? [];
+			if (related.length > 0) args.push("--related", related.join(","));
+			return args;
+		}
+		case "reindex":
+			return ["reindex"];
+		default: {
+			const exhaustive: never = params.action;
+			throw new Error(`Unsupported gnosis action: ${exhaustive}`);
+		}
+	}
+}
+
+function installHint(): string {
+	return [
+		"The `gn` CLI is required for the gnosis extension.",
+		"Install it with one of:",
+		"  brew install --cask skorokithakis/tap/gnosis",
+		"  go install github.com/skorokithakis/gnosis/cmd/gn@latest",
+	].join("\n");
+}
+
+function formatOutput(stdout: string, stderr: string): { text: string; truncated: boolean } {
+	const raw = [stdout, stderr].filter(Boolean).join(stderr && stdout ? "\n" : "").trimEnd();
+	if (!raw) return { text: "(no output)", truncated: false };
+
+	const truncation = truncateTail(raw, {
+		maxBytes: DEFAULT_MAX_BYTES,
+		maxLines: DEFAULT_MAX_LINES,
+	});
+
+	let text = truncation.content;
+	if (truncation.truncated) {
+		text += `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines`;
+		text += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).]`;
+	}
+	return { text, truncated: truncation.truncated };
+}
+
+export default function gnosisExtension(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gnosis",
+		label: "Gnosis",
+		description:
+			"Search and record repo-local project knowledge using the `gn` CLI. Supports plan/review doctrine, search, latest, show, topics, write, and reindex. Does not support edit/rm; use shell only with explicit user intent for destructive gnosis maintenance.",
+		executionMode: "sequential" as ToolExecutionMode,
+		promptSnippet: "Search and record repo-local project knowledge through gnosis (`gn`).",
+		promptGuidelines: [
+			"Use the gnosis tool before implementing changes that may touch prior architecture, project decisions, rejected alternatives, or human constraints.",
+			"Use gnosis with action=\"search\" and uppercase OR between likely topic keywords, for example `auth OR token OR session`.",
+			"Use gnosis with action=\"write\" only for durable, non-obvious project knowledge that is not already captured in code, comments, docs, or the commit message.",
+			"Prefer code comments over gnosis with action=\"write\" when the knowledge has an obvious specific code anchor.",
+		],
+		parameters: GnosisParams,
+
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			const args = buildGnosisArgs(params);
+
+			let result: Awaited<ReturnType<typeof pi.exec>>;
+			try {
+				result = await pi.exec("gn", args, {
+					cwd: ctx.cwd,
+					signal,
+					timeout: GNOSIS_TIMEOUT_MS,
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`${installHint()}\n\nExecution error: ${message}`);
+			}
+
+			const output = formatOutput(result.stdout ?? "", result.stderr ?? "");
+			if (result.killed) throw new Error(`gnosis ${params.action} timed out or was cancelled.\n\n${output.text}`);
+			if (result.code !== 0) {
+				throw new Error(`gnosis ${params.action} failed with exit code ${result.code}.\n\n${output.text}\n\n${installHint()}`);
+			}
+
+			return {
+				content: [{ type: "text", text: output.text }],
+				details: {
+					action: params.action,
+					args,
+					truncated: output.truncated,
+				},
+			};
+		},
+	});
+}

package/extensions/gnosis/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@diegopetrucci/pi-gnosis",
+  "version": "0.1.0",
+  "description": "A pi extension that exposes the gnosis repo-local knowledge base CLI as an agent tool.",
+  "keywords": ["pi-package", "pi", "gnosis", "memory", "knowledge-base", "tool"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegopetrucci/pi-extensions.git",
+    "directory": "extensions/gnosis"
+  },
+  "files": [
+    "index.ts",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}

package/extensions/oracle/README.md

@@ -38,6 +38,7 @@ Yes — the extension explicitly sets the oracle reasoning level.
 - reasoning models request `xhigh` by default, then use the Pi-compatible effective thinking level supported by the matched model
 - non-reasoning models default to `off`
 - you can override it with the tool's optional `thinkingLevel` parameter; matched models still clamp unsupported overrides and report the effective level
+- you can persist a default thinking level with `/oracle thinking <level>` so future automatic oracle tool calls use it when the agent does not pass a per-call override
 
 Use `/oracle-model` inside pi to see what it would pick right now.
 
@@ -81,12 +82,28 @@ Ask pi normally, for example:
 
 The main agent can call the tool directly.
 
+## User defaults
+
+Use `/oracle` to set persisted defaults that apply to future oracle tool calls, including calls the agent launches automatically without per-call overrides.
+
+```text
+/oracle status
+/oracle model anthropic/claude-opus-4-5
+/oracle thinking high
+/oracle thinking auto
+/oracle clear model
+/oracle clear thinking
+/oracle clear
+```
+
+Tool-call parameters still win over these defaults. `auto` clears the configured default and restores the built-in selection behavior. Preferences are saved under pi's agent directory in `extensions/oracle.json`.
+
 ## Tool parameters
 
 - `task` - required prompt for the oracle
 - `includeBash` - optional, adds `bash` for non-mutating inspection
-- `model` - optional explicit model override
-- `thinkingLevel` - optional reasoning/thinking override
+- `model` - optional explicit model override; falls back to the `/oracle model` default, then auto-selection
+- `thinkingLevel` - optional reasoning/thinking override; falls back to the `/oracle thinking` default, then built-in defaults
 - `cwd` - optional working directory override
 
 ## Notes

package/extensions/oracle/index.ts

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { basename } from "node:path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { getMarkdownTheme, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, getMarkdownTheme, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
@@ -58,6 +59,11 @@ interface OracleUiRun {
 	preview?: string;
 }
 
+interface OraclePreferences {
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+}
+
 const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"];
 const READ_ONLY_PLUS_BASH_TOOLS = [...READ_ONLY_TOOLS, "bash"];
 const DEFAULT_THINKING_LEVEL: ThinkingLevel = "xhigh";
@@ -65,6 +71,7 @@ const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as
 const COLLAPSED_LINE_LIMIT = 8;
 const ORACLE_STATUS_ID = "oracle";
 const ORACLE_WIDGET_ID = "oracle";
+const ORACLE_CONFIG_FILE = "oracle.json";
 
 const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	"amazon-bedrock": [
@@ -429,6 +436,74 @@ function createEmptyUsage(): UsageStats {
 	};
 }
 
+function getOracleConfigPath(): string {
+	return path.join(getAgentDir(), "extensions", ORACLE_CONFIG_FILE);
+}
+
+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();
+	return trimmed ? trimmed : undefined;
+}
+
+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 readOraclePreferences(): Promise<OraclePreferences> {
+	try {
+		const raw = await fs.readFile(getOracleConfigPath(), "utf8");
+		const parsed = JSON.parse(raw) as {
+			model?: unknown;
+			defaultModel?: unknown;
+			thinkingLevel?: unknown;
+			defaultThinkingLevel?: unknown;
+		};
+		return {
+			model: parseModelPreference(parsed.model).model ?? parseModelPreference(parsed.defaultModel).model,
+			thinkingLevel:
+				parseThinkingLevel(parsed.thinkingLevel) ??
+				parseThinkingLevel(parsed.defaultThinkingLevel) ??
+				parseModelPreference(parsed.model).thinkingLevel ??
+				parseModelPreference(parsed.defaultModel).thinkingLevel,
+		};
+	} catch {
+		return {};
+	}
+}
+
+async function writeOraclePreferences(preferences: OraclePreferences): Promise<void> {
+	const configPath = getOracleConfigPath();
+	const config = {
+		...(preferences.model ? { model: preferences.model } : {}),
+		...(preferences.thinkingLevel ? { thinkingLevel: preferences.thinkingLevel } : {}),
+		updatedAt: new Date().toISOString(),
+	};
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+function formatOraclePreferences(preferences: OraclePreferences): string {
+	const model = preferences.model ?? "auto";
+	const thinkingLevel = preferences.thinkingLevel ?? "auto";
+	return `Oracle defaults: model=${model}, thinkingLevel=${thinkingLevel}. Config: ${getOracleConfigPath()}`;
+}
+
+function notifyCommand(ctx: any, message: string, kind = "info"): void {
+	if (ctx.hasUI && ctx.ui) ctx.ui.notify(message, kind);
+	else console.log(message);
+}
+
 function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
 	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
@@ -534,7 +609,7 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
 		return { command: process.execPath, args: [currentScript, ...args] };
 	}
 
-	const execName = basename(process.execPath).toLowerCase();
+	const execName = path.basename(process.execPath).toLowerCase();
 	const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
 	if (!isGenericRuntime) {
 		return { command: process.execPath, args };
@@ -893,26 +968,147 @@ function renderCollapsedText(text: string, lineLimit = COLLAPSED_LINE_LIMIT): st
 
 export default function oracleExtension(pi: ExtensionAPI) {
 	const activeRuns = new Map<string, OracleUiRun>();
+	let preferences: OraclePreferences = {};
 
 	pi.on("session_start", async (_event, ctx) => {
+		preferences = await readOraclePreferences();
 		activeRuns.clear();
 		updateOracleUi(ctx, activeRuns);
 	});
 
+	pi.registerCommand("oracle", {
+		description: "Configure Oracle default model and thinking level for future oracle tool calls",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.trim().toLowerCase().split(/\s+/).filter(Boolean);
+			const first = parts[0] ?? "";
+			if (parts.length <= 1) {
+				const commands = ["status", "model", "thinking", "clear"];
+				const matches = commands.filter((command) => command.startsWith(first));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			if (parts[0] === "thinking") {
+				const query = parts[1] ?? "";
+				const values = ["auto", ...THINKING_LEVELS];
+				const matches = values.filter((value) => value.startsWith(query));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			if (parts[0] === "clear") {
+				const query = parts[1] ?? "";
+				const values = ["all", "model", "thinking"];
+				const matches = values.filter((value) => value.startsWith(query));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const raw = args.trim();
+			const tokens = raw ? raw.split(/\s+/) : [];
+			const [command = "status", ...rest] = tokens;
+			const action = command.toLowerCase();
+			const configPath = getOracleConfigPath();
+
+			const save = async (next: OraclePreferences): Promise<string | undefined> => {
+				preferences = next;
+				try {
+					await writeOraclePreferences(preferences);
+					return undefined;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return `Preference changed for this process, but could not save ${configPath}: ${message}`;
+				}
+			};
+
+			if (action === "status" || action === "show") {
+				notifyCommand(ctx, formatOraclePreferences(preferences));
+				return;
+			}
+
+			if (action === "model") {
+				const model = rest.join(" ").trim();
+				const normalizedModelAction = model.toLowerCase();
+				if (!model) {
+					notifyCommand(ctx, "Usage: /oracle model <provider/model|auto>", "warning");
+					return;
+				}
+				if (normalizedModelAction === "auto" || normalizedModelAction === "clear" || normalizedModelAction === "default") {
+					const warning = await save({ ...preferences, model: undefined });
+					notifyCommand(ctx, `Oracle default model cleared; future oracle calls will auto-select. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+					return;
+				}
+				const parsedModel = parseModelPreference(model);
+				const next = {
+					...preferences,
+					model: parsedModel.model,
+					thinkingLevel: parsedModel.thinkingLevel ?? preferences.thinkingLevel,
+				};
+				const warning = await save(next);
+				notifyCommand(ctx, `Oracle default model set to ${parsedModel.model}. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "thinking" || action === "think" || action === "thinking-level") {
+				const value = rest[0]?.trim().toLowerCase();
+				if (!value) {
+					notifyCommand(ctx, `Usage: /oracle thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				if (value === "auto" || value === "clear" || value === "default") {
+					const warning = await save({ ...preferences, thinkingLevel: undefined });
+					notifyCommand(ctx, `Oracle default thinking level cleared; future oracle calls will use built-in defaults. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+					return;
+				}
+				const thinkingLevel = parseThinkingLevel(value);
+				if (!thinkingLevel) {
+					notifyCommand(ctx, `Usage: /oracle thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				const warning = await save({ ...preferences, thinkingLevel });
+				notifyCommand(ctx, `Oracle default thinking level set to ${thinkingLevel}. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "clear" || action === "reset") {
+				const target = rest[0]?.trim().toLowerCase() || "all";
+				let next: OraclePreferences;
+				if (target === "all") next = {};
+				else if (target === "model") next = { ...preferences, model: undefined };
+				else if (target === "thinking" || target === "thinking-level") next = { ...preferences, thinkingLevel: undefined };
+				else {
+					notifyCommand(ctx, "Usage: /oracle clear [all|model|thinking]", "warning");
+					return;
+				}
+				const warning = await save(next);
+				notifyCommand(ctx, `Oracle defaults cleared (${target}). ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			notifyCommand(ctx, "Usage: /oracle status | model <provider/model|auto> | thinking <off|minimal|low|medium|high|xhigh|auto> | clear [all|model|thinking]", "warning");
+		},
+	});
+
 	pi.registerCommand("oracle-model", {
 		description: "Show which model the oracle would use right now",
 		handler: async (_args, ctx) => {
-			const selectionResult = await selectOracleModel(ctx);
+			const defaultModel = parseModelPreference(preferences.model);
+			if (defaultModel.model) {
+				const matched = await findAvailableModel(ctx, defaultModel.model);
+				const thinking = resolveThinkingLevel(matched, preferences.thinkingLevel ?? defaultModel.thinkingLevel);
+				const modelRef = matched ? `${matched.provider}/${matched.id}` : defaultModel.model;
+				const suffix = matched
+					? appendThinkingLevelClampReason("Configured default oracle model is active.", thinking)
+					: "Configured default oracle model is active, but it was not matched against the authenticated model list.";
+				notifyCommand(ctx, `Oracle: ${modelRef} (${thinking.effective}) — ${suffix}`);
+				return;
+			}
+			const selectionResult = await selectOracleModel(ctx, preferences.thinkingLevel);
 			if (!selectionResult.ok) {
-				if (ctx.hasUI) ctx.ui.notify(selectionResult.error, "error");
-				else console.log(selectionResult.error);
+				notifyCommand(ctx, selectionResult.error, "error");
 				return;
 			}
 
 			const { selection } = selectionResult;
 			const message = `Oracle: ${selection.modelRef} (${selection.thinkingLevel}) — ${selection.selectionReason}`;
-			if (ctx.hasUI) ctx.ui.notify(message, "info");
-			else console.log(message);
+			notifyCommand(ctx, message);
 		},
 	});
 
@@ -932,6 +1128,11 @@ export default function oracleExtension(pi: ExtensionAPI) {
 		parameters: OracleParams,
 
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const explicitModel = parseModelPreference(params.model);
+			const defaultModel = parseModelPreference(preferences.model);
+			const configuredModel = explicitModel.model ?? defaultModel.model;
+			const configuredThinkingLevel =
+				params.thinkingLevel ?? explicitModel.thinkingLevel ?? preferences.thinkingLevel ?? defaultModel.thinkingLevel;
 			const uiRun: OracleUiRun = {
 				task: params.task,
 				includeBash: params.includeBash ?? false,
@@ -942,16 +1143,24 @@ export default function oracleExtension(pi: ExtensionAPI) {
 
 			try {
 				let selection: OracleSelection;
-				if (params.model?.trim()) {
-					const modelRef = params.model.trim();
+				if (configuredModel) {
+					const modelRef = configuredModel;
 					const matched = await findAvailableModel(ctx, modelRef);
 					const provider =
 						matched?.provider ?? (modelRef.includes("/") ? modelRef.split("/")[0] : ctx.model?.provider ?? "unknown");
 					const modelId = matched?.id ?? (modelRef.includes("/") ? modelRef.split("/").slice(1).join("/") : modelRef);
-					const thinking = resolveThinkingLevel(matched, params.thinkingLevel);
+					const thinking = resolveThinkingLevel(matched, configuredThinkingLevel);
+					const usedToolOverride = !!explicitModel.model;
 					const selectionReason = matched
-						? appendThinkingLevelClampReason("Used the explicit model override provided in the tool call.", thinking)
-						: "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.";
+						? appendThinkingLevelClampReason(
+							usedToolOverride
+								? "Used the explicit model override provided in the tool call."
+								: "Used the configured default oracle model.",
+							thinking,
+						)
+						: usedToolOverride
+							? "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied."
+							: "Used the configured default oracle model. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.";
 					selection = {
 						modelRef: matched ? `${matched.provider}/${matched.id}` : modelRef,
 						provider,
@@ -965,7 +1174,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 						selectionReason,
 					};
 				} else {
-					const selectionResult = await selectOracleModel(ctx, params.thinkingLevel);
+					const selectionResult = await selectOracleModel(ctx, configuredThinkingLevel);
 					if (!selectionResult.ok) {
 						return {
 							content: [{ type: "text", text: selectionResult.error }],
@@ -974,7 +1183,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 								provider: ctx.model?.provider ?? "unknown",
 								modelId: "",
 								modelName: undefined,
-								thinkingLevel: params.thinkingLevel ?? DEFAULT_THINKING_LEVEL,
+								thinkingLevel: configuredThinkingLevel ?? DEFAULT_THINKING_LEVEL,
 								autoSelected: true,
 								selectionReason: selectionResult.error,
 								includeBash: params.includeBash ?? false,

package/extensions/oracle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-oracle",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "An Amp-style oracle extension for pi that consults the strongest reasoning model on your current provider.",
   "keywords": ["pi-package", "pi", "oracle", "reasoning", "subagent"],
   "license": "MIT",

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.29",
-  "description": "A collection of pi extensions for context management, workflow audits, review-comment triage, notifications, safety guards, GitHub research, todos, tool rendering, and model/provider helpers.",
-  "keywords": ["pi-package", "pi", "terminal", "agent"],
+  "version": "0.1.31",
+  "description": "A collection of pi extensions for context management, workflow audits, review-comment triage, notifications, safety guards, GitHub research, repo-local knowledge, todos, tool rendering, and model/provider helpers.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "terminal",
+    "agent"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -34,6 +39,7 @@
       "./extensions/context-cap/index.ts",
       "./extensions/context-inspector/index.ts",
       "./extensions/dirty-repo-guard/index.ts",
+      "./extensions/gnosis/index.ts",
       "./extensions/inline-bash/index.ts",
       "./extensions/librarian/index.ts",
       "./extensions/quiet-tools/index.ts",