@bdsqqq/pi 0.0.1

package/dist/extensions/handoff.js

@@ -0,0 +1,277 @@
+import { getExtensionConfig } from "../core/config.js";
+import { resolvePrompt } from "../core/pi-spawn.js";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { BorderedLoader, SessionManager, convertToLlm, serializeConversation } from "@mariozechner/pi-coding-agent";
+import { complete } from "@mariozechner/pi-ai";
+//#region packages/extensions/handoff/index.ts
+/**
+* handoff extension — replace compaction with LLM-driven context transfer.
+*
+* at ~85% context usage, generates a focused handoff prompt via LLM,
+* stages `/handoff` in the editor. user presses Enter → new session
+* with curated context, agent starts working immediately.
+*
+* manual usage anytime:
+*   /handoff implement this for teams
+*   /handoff execute phase one of the plan
+*   /handoff check other places that need this fix
+*/
+const CONFIG_DEFAULTS = {
+	threshold: .85,
+	model: {
+		provider: "openrouter",
+		id: "google/gemini-3-flash-preview"
+	},
+	promptFile: "",
+	promptString: ""
+};
+const MAX_RELEVANT_FILES = 10;
+function parsePromptSections(content) {
+	const sections = {};
+	const parts = content.split("\n# ");
+	for (const part of parts) {
+		const nl = part.indexOf("\n");
+		if (nl === -1) continue;
+		const name = part.slice(0, nl).trim();
+		const body = part.slice(nl + 1).trim();
+		if (name) sections[name] = body;
+	}
+	return sections;
+}
+function extractToolCallArgs(response) {
+	const toolCall = response.content.find((c) => c.type === "toolCall" && "name" in c && c.name === "create_handoff_context");
+	if (!toolCall) return null;
+	const args = toolCall.arguments;
+	return {
+		relevantInformation: args.relevantInformation ?? "",
+		relevantFiles: (Array.isArray(args.relevantFiles) ? args.relevantFiles : []).slice(0, MAX_RELEVANT_FILES)
+	};
+}
+function assembleHandoffPrompt(sessionId, extraction, goal) {
+	const parts = [];
+	parts.push(`Continuing work from session ${sessionId}. Use read_session to retrieve details if needed.`);
+	if (extraction.relevantFiles.length > 0) parts.push(extraction.relevantFiles.map((f) => `@${f}`).join(" "));
+	if (extraction.relevantInformation) parts.push(extraction.relevantInformation);
+	parts.push(goal);
+	return parts.join("\n\n");
+}
+const PROVENANCE_PREFIX = "↳ handed off from: ";
+const PROVENANCE_ELLIPSIS = "…";
+function getParentDescription(parentPath, maxWidth) {
+	const budget = maxWidth - 19 - 1;
+	try {
+		const session = SessionManager.open(parentPath);
+		const name = session.getSessionName();
+		if (name) return name.length > budget ? name.slice(0, Math.max(0, budget)) + PROVENANCE_ELLIPSIS : name;
+		const firstUser = session.getBranch().find((e) => e.type === "message" && "content" in e.message && e.message.role === "user");
+		if (firstUser) {
+			const content = firstUser.message.content;
+			const text = (Array.isArray(content) ? content : []).filter((c) => typeof c === "object" && c !== null && c.type === "text").map((c) => c.text).join(" ").trim();
+			if (text) return text.length > budget ? text.slice(0, Math.max(0, budget)) + PROVENANCE_ELLIPSIS : text;
+		}
+		return session.getHeader()?.id?.slice(0, 8) ?? parentPath.split("/").pop() ?? "unknown";
+	} catch {
+		return parentPath.split("/").pop() ?? "unknown";
+	}
+}
+function showProvenance(ctx, parentPath) {
+	ctx.ui.setWidget("handoff-provenance", (_tui, theme) => ({
+		render(width) {
+			const desc = getParentDescription(parentPath, width);
+			const content = theme.fg("dim", "↳ ") + truncateToWidth(`${PROVENANCE_PREFIX.slice(2)}${desc}`, width);
+			const contentWidth = visibleWidth(content);
+			const pad = Math.max(0, width - contentWidth);
+			return [" ".repeat(pad) + content];
+		},
+		invalidate() {}
+	}));
+}
+function handoff_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/handoff", CONFIG_DEFAULTS);
+	const handoffSections = parsePromptSections(resolvePrompt(cfg.promptString, cfg.promptFile));
+	const HANDOFF_TOOL = {
+		name: "create_handoff_context",
+		description: handoffSections["tool-description"] || "Extract context for handoff",
+		parameters: Type.Object({
+			relevantInformation: Type.String({ description: handoffSections["field-relevant-information"] || "Extract relevant context" }),
+			relevantFiles: Type.Array(Type.String(), { description: handoffSections["field-relevant-files"] || "Relevant file paths" })
+		})
+	};
+	function buildExtractionPrompt(conversationText, goal) {
+		return `${conversationText}\n\n${handoffSections["extraction-prompt"] ?? ""}\n${goal}\n\nUse the create_handoff_context tool to extract relevant information and files.`;
+	}
+	let storedHandoffPrompt = null;
+	let handoffPending = false;
+	let parentSessionFile;
+	let generating = false;
+	/** resolve the dedicated handoff model, fall back to ctx.model */
+	function getHandoffModel(ctx) {
+		return ctx.modelRegistry.find(cfg.model.provider, cfg.model.id) ?? ctx.model;
+	}
+	async function generateHandoffPrompt(ctx, handoffModel, goal, signal) {
+		const messages = ctx.sessionManager.getBranch().filter((e) => e.type === "message").map((e) => e.message);
+		if (messages.length === 0) return null;
+		const conversationText = serializeConversation(convertToLlm(messages));
+		const sessionId = ctx.sessionManager.getSessionId();
+		const apiKey = await ctx.modelRegistry.getApiKey(handoffModel);
+		const response = await complete(handoffModel, {
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: buildExtractionPrompt(conversationText, goal)
+				}],
+				timestamp: Date.now()
+			}],
+			tools: [HANDOFF_TOOL]
+		}, {
+			apiKey,
+			signal,
+			toolChoice: "any"
+		});
+		if (response.stopReason === "aborted") return null;
+		if (response.stopReason === "error") throw new Error(response.errorMessage ?? "API request failed");
+		const extraction = extractToolCallArgs(response);
+		if (!extraction) return null;
+		return assembleHandoffPrompt(sessionId, extraction, goal);
+	}
+	/** switch to a new session and send the handoff prompt */
+	async function executeHandoff(prompt, parent, ctx) {
+		storedHandoffPrompt = null;
+		handoffPending = false;
+		generating = false;
+		ctx.ui?.setStatus?.("handoff", "");
+		pi.events.emit("editor:remove-label", { key: "handoff" });
+		if ((await ctx.newSession({ parentSession: parent })).cancelled) return false;
+		if (parent) showProvenance(ctx, parent);
+		pi.sendUserMessage(prompt);
+		return true;
+	}
+	pi.on("session_start", async (_event, ctx) => {
+		const parentPath = ctx.sessionManager.getHeader()?.parentSession;
+		if (parentPath) showProvenance(ctx, parentPath);
+	});
+	pi.on("session_before_compact", async (_event, _ctx) => {
+		return { cancel: true };
+	});
+	pi.on("agent_end", async (_event, ctx) => {
+		if (handoffPending || generating) return;
+		const usage = ctx.getContextUsage();
+		if (!usage || usage.percent === null) return;
+		if (usage.percent < cfg.threshold * 100) return;
+		const handoffModel = getHandoffModel(ctx);
+		if (!handoffModel) return;
+		generating = true;
+		parentSessionFile = ctx.sessionManager.getSessionFile();
+		try {
+			const prompt = await generateHandoffPrompt(ctx, handoffModel, "continue the most specific pending task from the conversation");
+			if (!prompt) {
+				generating = false;
+				ctx.ui.notify("handoff generation failed: no extraction result", "error");
+				return;
+			}
+			storedHandoffPrompt = prompt;
+			handoffPending = true;
+			generating = false;
+			ctx.ui.setEditorText("/handoff");
+			ctx.ui.setStatus("handoff", `handoff ready (${Math.round(usage.percent)}%)`);
+			pi.events.emit("editor:set-label", {
+				key: "handoff",
+				text: `handoff ready (${Math.round(usage.percent)}%)`,
+				position: "top",
+				align: "right"
+			});
+			ctx.ui.notify(`context at ${Math.round(usage.percent)}% — handoff prompt generated. press enter to continue in a new session.`, "warning");
+		} catch (err) {
+			generating = false;
+			ctx.ui.notify(`handoff generation failed: ${String(err)}`, "error");
+		}
+	});
+	pi.registerCommand("handoff", {
+		description: "Transfer context to a new focused session (replaces compaction)",
+		handler: async (args, ctx) => {
+			const goal = args.trim();
+			if (goal && !handoffPending) {
+				const handoffModel = getHandoffModel(ctx);
+				if (!handoffModel) {
+					ctx.ui.notify("no model available for handoff", "error");
+					return;
+				}
+				parentSessionFile = ctx.sessionManager.getSessionFile();
+				const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+					const loader = new BorderedLoader(tui, theme, `generating handoff prompt (${handoffModel.name})...`);
+					loader.onAbort = () => done(null);
+					generateHandoffPrompt(ctx, handoffModel, goal, loader.signal).then(done).catch((err) => {
+						console.error("handoff generation failed:", err);
+						done(null);
+					});
+					return loader;
+				});
+				if (!result) {
+					ctx.ui.notify("cancelled", "info");
+					return;
+				}
+				storedHandoffPrompt = result;
+			}
+			if (!storedHandoffPrompt) {
+				ctx.ui.notify("no handoff prompt available. usage: /handoff <goal>", "error");
+				return;
+			}
+			const edited = await ctx.ui.editor("handoff prompt — ⏎ to handoff ␛ to cancel", storedHandoffPrompt);
+			if (!edited) {
+				ctx.ui.notify("handoff cancelled", "info");
+				return;
+			}
+			const prompt = edited;
+			if (!await executeHandoff(prompt, parentSessionFile, ctx)) {
+				storedHandoffPrompt = prompt;
+				handoffPending = true;
+				ctx.ui.notify("session switch cancelled", "info");
+			}
+		}
+	});
+	pi.on("session_switch", async (_event, ctx) => {
+		storedHandoffPrompt = null;
+		handoffPending = false;
+		generating = false;
+		pi.events.emit("editor:remove-label", { key: "handoff" });
+		ctx.ui.setWidget("handoff-provenance", void 0);
+	});
+	const handoffTool = {
+		name: "handoff",
+		label: "Handoff",
+		description: "Hand off to a new session. Generates a handoff prompt from the current conversation and stages /handoff in the editor. The user presses Enter to review the prompt, then confirms to switch sessions.",
+		promptSnippet: "Hand off to a new session with a generated context transfer prompt",
+		promptGuidelines: ["Use this when context is getting crowded or the user asks to continue in a fresh session.", "Set goal to a specific next task, not a vague continuation."],
+		parameters: Type.Object({ goal: Type.String({ description: "What should be accomplished in the new session. Be specific about the next task." }) }),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			const handoffModel = getHandoffModel(_ctx);
+			if (!handoffModel) throw new Error("no model available for handoff extraction");
+			parentSessionFile = _ctx.sessionManager.getSessionFile();
+			const prompt = await generateHandoffPrompt(_ctx, handoffModel, p.goal, _signal ?? void 0);
+			if (!prompt) throw new Error("handoff generation failed: could not extract context");
+			storedHandoffPrompt = prompt;
+			handoffPending = true;
+			_ctx.ui.setEditorText("/handoff");
+			_ctx.ui.setStatus("handoff", "handoff ready");
+			pi.events.emit("editor:set-label", {
+				key: "handoff",
+				text: "handoff ready",
+				position: "top",
+				align: "right"
+			});
+			return {
+				content: [{
+					type: "text",
+					text: `handoff prompt generated for: "${p.goal}". staged /handoff — press Enter to continue in a new session.`
+				}],
+				details: void 0
+			};
+		}
+	};
+	pi.registerTool(handoffTool);
+}
+//#endregion
+export { handoff_default as default };

package/dist/extensions/librarian.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/librarian/index.d.ts
+interface LibrarianConfig {
+  systemPrompt?: string;
+  model?: string;
+  extensionTools?: string[];
+  builtinTools?: string[];
+}
+declare function createLibrarianTool(config?: LibrarianConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { LibrarianConfig, createLibrarianTool, export_default as default };

package/dist/extensions/librarian.js

@@ -0,0 +1,113 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { getExtensionConfig } from "../core/config.js";
+import { piSpawn, resolvePrompt, zeroUsage } from "../core/pi-spawn.js";
+import { getFinalOutput, renderAgentTree, subAgentResult } from "../core/sub-agent-render.js";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/librarian/index.ts
+const CONFIG_DEFAULTS = {
+	model: "openrouter/anthropic/claude-haiku-4.5",
+	extensionTools: [
+		"read_github",
+		"search_github",
+		"list_directory_github",
+		"list_repositories",
+		"glob_github",
+		"commit_search",
+		"diff",
+		"web_search"
+	],
+	builtinTools: [],
+	promptFile: "",
+	promptString: ""
+};
+function createLibrarianTool(config = {}) {
+	return {
+		name: "librarian",
+		label: "Librarian",
+		description: "The Librarian — a specialized codebase understanding agent that helps answer questions about large, complex codebases across GitHub repositories.\n\nThe Librarian reads from GitHub — it can see public repositories and private repositories you have access to via `gh` CLI auth.\n\nWHEN TO USE THE LIBRARIAN:\n- Understanding complex multi-repository codebases\n- Exploring relationships between different repositories\n- Analyzing architectural patterns across projects\n- Finding specific implementations across codebases\n- Understanding code evolution and commit history\n- Getting comprehensive explanations of how features work\n\nWHEN NOT TO USE THE LIBRARIAN:\n- Simple local file reading (use Read directly)\n- Local codebase searches (use finder)\n- Code modifications (use other tools)\n\nUSAGE GUIDELINES:\n- Be specific about what repositories or projects you want to understand\n- Provide context about what you're trying to achieve\n- The Librarian explores thoroughly before providing comprehensive answers\n- When getting an answer from the Librarian, show it to the user in full, do not summarize it.",
+		parameters: Type.Object({
+			query: Type.String({ description: "Your question about the codebase. Be specific about what you want to understand." }),
+			context: Type.Optional(Type.String({ description: "Optional context about what you're trying to achieve or background information." }))
+		}),
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const p = params;
+			const parts = [p.query];
+			if (p.context) parts.push(`\nContext: ${p.context}`);
+			const fullTask = parts.join("\n");
+			const singleResult = {
+				agent: "librarian",
+				task: p.query,
+				exitCode: -1,
+				messages: [],
+				usage: zeroUsage()
+			};
+			const result = await piSpawn({
+				cwd: ctx.cwd,
+				task: fullTask,
+				model: config.model ?? CONFIG_DEFAULTS.model,
+				builtinTools: config.builtinTools ?? CONFIG_DEFAULTS.builtinTools,
+				extensionTools: config.extensionTools ?? CONFIG_DEFAULTS.extensionTools,
+				systemPromptBody: config.systemPrompt,
+				signal,
+				sessionId,
+				onUpdate: (partial) => {
+					singleResult.messages = partial.messages;
+					singleResult.usage = partial.usage;
+					singleResult.model = partial.model;
+					singleResult.stopReason = partial.stopReason;
+					singleResult.errorMessage = partial.errorMessage;
+					if (onUpdate) onUpdate({
+						content: [{
+							type: "text",
+							text: getFinalOutput(partial.messages) || "(exploring...)"
+						}],
+						details: singleResult
+					});
+				}
+			});
+			singleResult.exitCode = result.exitCode;
+			singleResult.messages = result.messages;
+			singleResult.usage = result.usage;
+			singleResult.model = result.model;
+			singleResult.stopReason = result.stopReason;
+			singleResult.errorMessage = result.errorMessage;
+			const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+			const output = getFinalOutput(result.messages) || "(no output)";
+			if (isError) return subAgentResult(result.errorMessage || result.stderr || output, singleResult, true);
+			return subAgentResult(output, singleResult);
+		},
+		renderCall(args, theme) {
+			const preview = args.query ? args.query.length > 80 ? `${args.query.slice(0, 80)}...` : args.query : "...";
+			return new Text(theme.fg("toolTitle", theme.bold("librarian ")) + theme.fg("dim", preview), 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			const details = result.details;
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+			}
+			const container = new Container();
+			renderAgentTree(details, container, expanded, theme, {
+				label: "librarian",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function librarian_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/librarian", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createLibrarianTool({
+		systemPrompt: resolvePrompt(cfg.promptString, cfg.promptFile),
+		model: cfg.model,
+		extensionTools: cfg.extensionTools,
+		builtinTools: cfg.builtinTools
+	})));
+}
+//#endregion
+export { createLibrarianTool, librarian_default as default };

package/dist/extensions/look-at.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/look-at/index.d.ts
+interface LookAtConfig {
+  systemPrompt?: string;
+  model?: string;
+  extensionTools?: string[];
+  builtinTools?: string[];
+}
+declare function createLookAtTool(config?: LookAtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { LookAtConfig, createLookAtTool, export_default as default };

package/dist/extensions/look-at.js

@@ -0,0 +1,121 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { getExtensionConfig } from "../core/config.js";
+import { piSpawn, resolvePrompt, zeroUsage } from "../core/pi-spawn.js";
+import { getFinalOutput, renderAgentTree, subAgentResult } from "../core/sub-agent-render.js";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/look-at/index.ts
+const CONFIG_DEFAULTS = {
+	model: "openrouter/google/gemini-3-flash-preview",
+	extensionTools: ["read", "ls"],
+	builtinTools: ["read", "ls"],
+	promptFile: "",
+	promptString: ""
+};
+const DEFAULT_SYSTEM_PROMPT = `Analyze the provided file and answer the user's question about it. Be concise and direct, reference specific locations. When comparing files, systematically identify differences.`;
+function createLookAtTool(config = {}) {
+	return {
+		name: "look_at",
+		label: "Look At",
+		description: "Extract specific information from a local file (including images and other media).\n\nUse this tool when you need to extract or summarize information from a file without getting the literal contents. Always provide a clear objective.\n\nPass reference files when you need to compare two or more things.\n\n## When to use this tool\n\n- Analyzing images that the Read tool cannot interpret\n- Extracting specific information or summaries from documents\n- Describing visual content in images or diagrams\n- When you only need analyzed/extracted data, not raw file contents\n\n## When NOT to use this tool\n\n- For source code or plain text files where you need exact contents — use Read instead\n- When you need to edit the file afterward (you need literal content from Read)\n- For simple file reading where no interpretation is needed",
+		parameters: Type.Object({
+			path: Type.String({ description: "Workspace-relative or absolute path to the file to analyze." }),
+			objective: Type.String({ description: "Natural-language description of the analysis goal (e.g., summarize, extract data, describe image)." }),
+			context: Type.String({ description: "The broader goal and context for the analysis." }),
+			referenceFiles: Type.Optional(Type.Array(Type.String(), { description: "Optional list of paths to reference files for comparison." }))
+		}),
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const parts = [];
+			parts.push(`Read the file at "${p.path}" using the read tool.`);
+			if (p.referenceFiles && p.referenceFiles.length > 0) for (const ref of p.referenceFiles) parts.push(`Also read the reference file at "${ref}".`);
+			parts.push("");
+			parts.push(`Context: ${p.context}`);
+			parts.push("");
+			parts.push(`Analyze with this objective: ${p.objective}`);
+			if (p.referenceFiles && p.referenceFiles.length > 0) {
+				parts.push("");
+				parts.push("Compare the main file against the reference file(s). Identify all differences and similarities.");
+			}
+			const fullTask = parts.join("\n");
+			const singleResult = {
+				agent: "look_at",
+				task: p.objective,
+				exitCode: -1,
+				messages: [],
+				usage: zeroUsage()
+			};
+			const systemPrompt = config.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+			const result = await piSpawn({
+				cwd: ctx.cwd,
+				task: fullTask,
+				model: config.model ?? CONFIG_DEFAULTS.model,
+				builtinTools: config.builtinTools ?? CONFIG_DEFAULTS.builtinTools,
+				extensionTools: config.extensionTools ?? CONFIG_DEFAULTS.extensionTools,
+				systemPromptBody: systemPrompt,
+				signal,
+				sessionId,
+				onUpdate: (partial) => {
+					singleResult.messages = partial.messages;
+					singleResult.usage = partial.usage;
+					singleResult.model = partial.model;
+					singleResult.stopReason = partial.stopReason;
+					singleResult.errorMessage = partial.errorMessage;
+					if (onUpdate) onUpdate({
+						content: [{
+							type: "text",
+							text: getFinalOutput(partial.messages) || "(analyzing...)"
+						}],
+						details: singleResult
+					});
+				}
+			});
+			singleResult.exitCode = result.exitCode;
+			singleResult.messages = result.messages;
+			singleResult.usage = result.usage;
+			singleResult.model = result.model;
+			singleResult.stopReason = result.stopReason;
+			singleResult.errorMessage = result.errorMessage;
+			const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+			const output = getFinalOutput(result.messages) || "(no output)";
+			if (isError) return subAgentResult(result.errorMessage || result.stderr || output, singleResult, true);
+			return subAgentResult(output, singleResult);
+		},
+		renderCall(args, theme) {
+			const path = args.path || "...";
+			const objective = args.objective ? args.objective.length > 60 ? `${args.objective.slice(0, 60)}...` : args.objective : "";
+			let text = theme.fg("toolTitle", theme.bold("look_at ")) + theme.fg("dim", path);
+			if (objective) text += theme.fg("muted", ` — ${objective}`);
+			if (args.referenceFiles?.length) text += theme.fg("muted", ` (+${args.referenceFiles.length} ref${args.referenceFiles.length > 1 ? "s" : ""})`);
+			return new Text(text, 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			const details = result.details;
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+			}
+			const container = new Container();
+			renderAgentTree(details, container, expanded, theme, {
+				label: "look_at",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function look_at_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/look-at", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createLookAtTool({
+		systemPrompt: resolvePrompt(cfg.promptString, cfg.promptFile),
+		model: cfg.model,
+		extensionTools: cfg.extensionTools,
+		builtinTools: cfg.builtinTools
+	})));
+}
+//#endregion
+export { createLookAtTool, look_at_default as default };

package/dist/extensions/ls.d.ts

@@ -0,0 +1,8 @@
+import { ReadLimits } from "./read.js";
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/ls/index.d.ts
+declare function createLsTool(limits: ReadLimits): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createLsTool, export_default as default };

package/dist/extensions/ls.js

@@ -0,0 +1,87 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link, textSection } from "../core/box-format.js";
+import { NORMAL_LIMITS, listDirectory, resolveWithVariants } from "./read.js";
+import * as fs from "node:fs";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/ls/index.ts
+/**
+* ls tool shadow — redirects to read's directory listing.
+*
+* directory listing is part of Read.
+* pi has a built-in ls tool that models may call by habit. this shadow
+* does the listing (no wasted tool call) but steers the model toward
+* using read for future calls.
+*/
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+function createLsTool(limits) {
+	return {
+		name: "ls",
+		label: "List Directory",
+		description: "List directory contents. Prefer using the read tool instead — it handles both files and directories.",
+		parameters: Type.Object({ path: Type.Optional(Type.String({ description: "The absolute path to the directory to list. Defaults to cwd." })) }),
+		renderCall(args, theme) {
+			const dirPath = args.path || ".";
+			const home = os.homedir();
+			const shortened = dirPath.startsWith(home) ? `~${dirPath.slice(home.length)}` : dirPath;
+			const linked = dirPath.startsWith("/") ? osc8Link(`file://${dirPath}`, shortened) : shortened;
+			return new Text(theme.fg("toolTitle", theme.bold("ls ")) + theme.fg("dim", linked), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		},
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const resolved = resolveWithVariants(params.path ?? ctx.cwd, ctx.cwd);
+			if (!fs.existsSync(resolved)) return {
+				content: [{
+					type: "text",
+					text: `directory not found: ${resolved}`
+				}],
+				isError: true
+			};
+			if (!fs.statSync(resolved).isDirectory()) return {
+				content: [{
+					type: "text",
+					text: `not a directory: ${resolved}. use the read tool for files.`
+				}],
+				isError: true
+			};
+			try {
+				let text = listDirectory(resolved, limits.maxDirEntries);
+				text += "\n\n(note: prefer the read tool for directory listing — it handles both files and directories.)";
+				return {
+					content: [{
+						type: "text",
+						text
+					}],
+					details: { header: resolved }
+				};
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: err.message
+					}],
+					isError: true
+				};
+			}
+		}
+	};
+}
+function ls_default(pi) {
+	pi.registerTool(withPromptPatch(createLsTool(NORMAL_LIMITS)));
+}
+//#endregion
+export { createLsTool, ls_default as default };

package/dist/extensions/mermaid.d.ts

@@ -0,0 +1,20 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/mermaid/index.d.ts
+type DiagramEntry = {
+  id: string;
+  block: {
+    code: string;
+    blockIndex: number;
+    startLine: number;
+    endLine: number;
+  };
+  context: {
+    beforeLines: string[];
+    afterLines: string[];
+  };
+  source: "assistant" | "user" | "command";
+};
+declare function mermaidInlineExtension(pi: ExtensionAPI): void;
+//#endregion
+export { DiagramEntry, mermaidInlineExtension as default };

package/dist/extensions/mermaid.js

@@ -0,0 +1,2 @@
+import { t as mermaidInlineExtension } from "../mermaid-C7xCVBrw.js";
+export { mermaidInlineExtension as default };

package/dist/extensions/oracle.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/oracle/index.d.ts
+interface OracleConfig {
+  systemPrompt?: string;
+  model?: string;
+  extensionTools?: string[];
+  builtinTools?: string[];
+}
+declare function createOracleTool(config?: OracleConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { OracleConfig, createOracleTool, export_default as default };