@bdsqqq/pi 0.0.1

package/dist/extensions/oracle.js

@@ -0,0 +1,143 @@
+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 * as fs from "node:fs";
+import * as path from "node:path";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/oracle/index.ts
+/**
+* oracle tool — expert technical advisor via gpt-5.2 sub-agent.
+*
+* replaces the generic subagent(agent: "oracle", task: ...) pattern
+* with a dedicated tool. the model calls
+* oracle(task: "...", context?: "...", files?: [...]) directly.
+*
+* the oracle operates zero-shot: no follow-up questions, makes its
+* final message comprehensive. only the last assistant message is
+* returned to the parent agent.
+*
+* system prompt loaded from sops-decrypted prompts at init time.
+*/
+const CONFIG_DEFAULTS = {
+	model: "openrouter/openai/gpt-5.2",
+	extensionTools: [
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"bash"
+	],
+	builtinTools: [
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"bash"
+	],
+	promptFile: "",
+	promptString: ""
+};
+function createOracleTool(config = {}) {
+	return {
+		name: "oracle",
+		label: "Oracle",
+		description: "Consult the oracle - an AI advisor powered by a reasoning model that can plan, review, and provide expert guidance.\n\nThe oracle has access to tools: Read, Grep, Find, ls, Bash.\n\nYou should consult the oracle for:\n- Code reviews and architecture feedback\n- Finding difficult bugs across many files\n- Planning complex implementations or refactors\n- Answering complex technical questions requiring deep reasoning\n- Providing an alternative point of view\n\nYou should NOT consult the oracle for:\n- File reads or simple keyword searches (use Read or Grep directly)\n- Codebase searches (use finder)\n- Basic code modifications (do it yourself or use Task)\n\nUsage guidelines:\n- Be specific about what you want reviewed, planned, or debugged\n- Provide relevant context. If you know which files are involved, list them.",
+		parameters: Type.Object({
+			task: Type.String({ description: "The task or question for the oracle. Be specific about what guidance you need." }),
+			context: Type.Optional(Type.String({ description: "Optional context about the current situation or background information." })),
+			files: Type.Optional(Type.Array(Type.String(), { description: "Optional file paths the oracle should examine." }))
+		}),
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const parts = [p.task];
+			if (p.context) parts.push(`\nContext: ${p.context}`);
+			if (p.files && p.files.length > 0) for (const filePath of p.files) {
+				const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.cwd, filePath);
+				try {
+					const content = fs.readFileSync(resolved, "utf-8");
+					parts.push(`\nFile: ${filePath}\n\`\`\`\n${content}\n\`\`\``);
+				} catch {
+					parts.push(`\nFile: ${filePath} (could not read)`);
+				}
+			}
+			const fullTask = parts.join("\n");
+			const singleResult = {
+				agent: "oracle",
+				task: p.task,
+				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) || "(thinking...)"
+						}],
+						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.task ? args.task.length > 80 ? `${args.task.slice(0, 80)}...` : args.task : "...";
+			let text = theme.fg("toolTitle", theme.bold("oracle ")) + theme.fg("dim", preview);
+			if (args.files?.length) text += theme.fg("muted", ` (${args.files.length} file${args.files.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: "oracle",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function oracle_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/oracle", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createOracleTool({
+		systemPrompt: resolvePrompt(cfg.promptString, cfg.promptFile),
+		model: cfg.model,
+		extensionTools: cfg.extensionTools,
+		builtinTools: cfg.builtinTools
+	})));
+}
+//#endregion
+export { createOracleTool, oracle_default as default };

package/dist/extensions/read-session.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/read-session/index.d.ts
+interface ReadSessionConfig {
+  systemPrompt?: string;
+  model?: string;
+  sessionsDir: string;
+  maxChars: number;
+}
+declare function createReadSessionTool(config: ReadSessionConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { ReadSessionConfig, createReadSessionTool, export_default as default };

package/dist/extensions/read-session.js

@@ -0,0 +1,265 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { headTailChars } from "../core/output-buffer.js";
+import { getExtensionConfig } from "../core/config.js";
+import { piSpawn, zeroUsage } from "../core/pi-spawn.js";
+import { getFinalOutput, renderAgentTree, subAgentResult } from "../core/sub-agent-render.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/read-session/index.ts
+/**
+* read_session tool — extract relevant context from a pi session via sub-agent.
+*
+* loads a full session tree (all branches), renders it as structured markdown,
+* then spawns a gemini flash sub-agent to extract only the information
+* relevant to the stated goal. the agent sees the complete tree — including
+* abandoned branches — so it can understand decision points and context.
+*
+* branch awareness: if a leaf_id is provided, the target branch is annotated
+* in the rendered output so the agent knows which path to focus on.
+*/
+const CONFIG_DEFAULTS = {
+	model: "openrouter/google/gemini-3-flash-preview",
+	sessionsDir: path.join(os.homedir(), ".pi", "agent", "sessions"),
+	maxChars: 12e4
+};
+const DEFAULT_SYSTEM_PROMPT = `You are analyzing a pi coding agent session transcript. Extract information relevant to the user's goal. Be specific — cite file paths, decisions made, code patterns discussed. If a specific branch is marked as the target, focus on that branch but use other branches for context about what was tried and abandoned.`;
+function findSessionFile(sessionId, sessionsDir) {
+	if (!fs.existsSync(sessionsDir)) return null;
+	const walkDir = (dir) => {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				const found = walkDir(full);
+				if (found) return found;
+			} else if (entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)) return full;
+		}
+		return null;
+	};
+	let found = walkDir(sessionsDir);
+	if (found) return found;
+	const walkAndParse = (dir) => {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				const f = walkAndParse(full);
+				if (f) return f;
+			} else if (entry.name.endsWith(".jsonl")) try {
+				const firstLine = fs.readFileSync(full, "utf-8").split("\n")[0];
+				if (!firstLine) continue;
+				const header = JSON.parse(firstLine);
+				if (header.type === "session" && header.id === sessionId) return full;
+			} catch {}
+		}
+		return null;
+	};
+	return walkAndParse(sessionsDir);
+}
+function renderSessionTree(filePath, targetLeafId, maxChars) {
+	const lines = fs.readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim());
+	const entries = [];
+	let sessionId = "";
+	let sessionName = "";
+	let cwd = "";
+	let timestamp = "";
+	for (const line of lines) try {
+		const entry = JSON.parse(line);
+		if (entry.type === "session") {
+			sessionId = entry.id;
+			cwd = entry.cwd || "";
+			timestamp = entry.timestamp || "";
+		}
+		if (entry.type === "session_info" && entry.name) sessionName = entry.name;
+		if (entry.id) entries.push(entry);
+	} catch {}
+	const byId = /* @__PURE__ */ new Map();
+	const children = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		byId.set(e.id, e);
+		const parent = e.parentId ?? "__root__";
+		if (!children.has(parent)) children.set(parent, []);
+		children.get(parent).push(e.id);
+	}
+	const targetPath = /* @__PURE__ */ new Set();
+	if (targetLeafId) {
+		let current = targetLeafId;
+		while (current) {
+			targetPath.add(current);
+			const entry = byId.get(current);
+			if (!entry?.parentId) break;
+			current = entry.parentId;
+		}
+	}
+	const branchPoints = /* @__PURE__ */ new Set();
+	for (const [parentId, kids] of children.entries()) if (kids.length > 1) branchPoints.add(parentId);
+	const parts = [];
+	parts.push(`# session: ${sessionName || sessionId}`);
+	parts.push(`id: ${sessionId}`);
+	parts.push(`workspace: ${cwd}`);
+	parts.push(`started: ${timestamp}`);
+	if (targetLeafId) parts.push(`target branch leaf: ${targetLeafId}`);
+	parts.push("");
+	const renderEntry = (entryId, depth) => {
+		const entry = byId.get(entryId);
+		if (!entry) return;
+		const marker = targetPath.has(entryId) ? " [TARGET BRANCH]" : "";
+		const kids = children.get(entryId) || [];
+		if (kids.length > 1) parts.push(`\n--- branch point (${kids.length} paths) ---\n`);
+		if (entry.type === "message") {
+			const msg = entry.message;
+			if (!msg) return;
+			if (msg.role === "user") {
+				const textParts = msg.content?.filter((p) => p.type === "text").map((p) => p.text).join("\n") || "";
+				if (textParts) {
+					parts.push(`## user${marker}`);
+					parts.push(textParts);
+					parts.push("");
+				}
+			} else if (msg.role === "assistant") {
+				const textParts = [];
+				const toolCalls = [];
+				for (const part of msg.content || []) if (part.type === "text" && part.text) textParts.push(part.text);
+				else if (part.type === "toolCall") {
+					const args = part.arguments ? JSON.stringify(part.arguments).slice(0, 200) : "";
+					toolCalls.push(`${part.name}(${args})`);
+				}
+				if (textParts.length > 0 || toolCalls.length > 0) {
+					parts.push(`## assistant${marker}`);
+					if (textParts.length > 0) parts.push(textParts.join("\n"));
+					if (toolCalls.length > 0) parts.push(`\ntool calls: ${toolCalls.join(", ")}`);
+					parts.push("");
+				}
+			} else if (msg.role === "toolResult") {
+				const toolName = msg.toolName || "?";
+				const textContent = msg.content?.filter((p) => p.type === "text").map((p) => p.text).join("\n") || "";
+				const truncated = textContent.length > 500 ? `${textContent.slice(0, 500)}... (truncated)` : textContent;
+				if (truncated) {
+					parts.push(`### ${toolName} result${msg.isError ? " (ERROR)" : ""}${marker}`);
+					parts.push(truncated);
+					parts.push("");
+				}
+			}
+		} else if (entry.type === "model_change") parts.push(`*model changed to ${String(entry.modelId)}*\n`);
+		for (const childId of kids) renderEntry(childId, depth + 1);
+	};
+	const rootIds = children.get("__root__") || [];
+	for (const e of entries) if (e.parentId && !byId.has(e.parentId) && !rootIds.includes(e.id)) rootIds.push(e.id);
+	for (const rootId of rootIds) renderEntry(rootId, 0);
+	let markdown = parts.join("\n");
+	const truncated = headTailChars(markdown, maxChars);
+	if (truncated.truncated) markdown = truncated.text;
+	return {
+		markdown,
+		sessionName,
+		sessionId
+	};
+}
+function createReadSessionTool(config) {
+	return {
+		name: "read_session",
+		label: "Read Session",
+		description: "Read and extract relevant content from a past pi session.\n\nLoads the full session tree (all branches, including abandoned paths), then uses AI to extract only the information relevant to your stated goal. The AI sees the complete tree to understand decision points and context.\n\nUse `search_sessions` first to find session IDs and branch leaf IDs.\n\nWHEN TO USE:\n- Extracting context from a previous session\n- Understanding what was tried and decided in a past session\n- Continuing work from a prior session\n\nWHEN NOT TO USE:\n- Current session context (already available)\n- Finding sessions (use search_sessions first)",
+		parameters: Type.Object({
+			session_id: Type.String({ description: "The session ID to read (from search_sessions results)." }),
+			goal: Type.String({ description: "What information you're looking for. Be specific about what to extract." }),
+			leaf_id: Type.Optional(Type.String({ description: "Optional branch leaf ID to focus on. The AI will see all branches but prioritize the target branch." }))
+		}),
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			const sessionFile = findSessionFile(p.session_id, config.sessionsDir);
+			if (!sessionFile) return {
+				content: [{
+					type: "text",
+					text: `session not found: ${p.session_id}`
+				}],
+				isError: true
+			};
+			const { markdown } = renderSessionTree(sessionFile, p.leaf_id, config.maxChars);
+			if (!markdown.trim()) return { content: [{
+				type: "text",
+				text: "(session is empty)"
+			}] };
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const task = `Here is a pi coding agent session transcript:\n\n${markdown}\n\n---\n\nExtract the information relevant to this goal: ${p.goal}`;
+			const singleResult = {
+				agent: "read_session",
+				task: p.goal,
+				exitCode: -1,
+				messages: [],
+				usage: zeroUsage()
+			};
+			const systemPrompt = config.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+			const result = await piSpawn({
+				cwd: ctx.cwd,
+				task,
+				model: config.model ?? CONFIG_DEFAULTS.model,
+				builtinTools: [],
+				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) || "(reading session...)"
+						}],
+						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 goal = args.goal ? args.goal.length > 60 ? `${args.goal.slice(0, 60)}...` : args.goal : "...";
+			let text = theme.fg("toolTitle", theme.bold("read_session ")) + theme.fg("dim", goal);
+			if (args.session_id) {
+				const shortId = args.session_id.length > 8 ? args.session_id.slice(0, 8) : args.session_id;
+				text += theme.fg("muted", ` (${shortId}...)`);
+			}
+			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: "read_session",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function read_session_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/read-session", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createReadSessionTool({
+		model: cfg.model,
+		sessionsDir: cfg.sessionsDir,
+		maxChars: cfg.maxChars
+	})));
+}
+//#endregion
+export { createReadSessionTool, read_session_default as default };

package/dist/extensions/read-web-page.d.ts

@@ -0,0 +1,11 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/read-web-page/index.d.ts
+interface ReadWebPageConfig {
+  systemPrompt?: string;
+  model?: string;
+}
+declare function createReadWebPageTool(config?: ReadWebPageConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { ReadWebPageConfig, createReadWebPageTool, export_default as default };

package/dist/extensions/read-web-page.js

@@ -0,0 +1,234 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { osc8Link } from "../core/box-format.js";
+import { OutputBuffer, headTailChars } from "../core/output-buffer.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 { htmlToMarkdown } from "../core/html-to-md.js";
+import { spawn } from "node:child_process";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/read-web-page/index.ts
+/**
+* v3: cheerio HTML→markdown + LLM Q&A + pagination + raw mode.
+*
+* cheerio strips chrome (nav, footer, scripts), finds main content area,
+* converts to clean markdown. ~95% size reduction on typical pages.
+*
+* `prompt` spawns a gemini flash sub-agent that receives page content
+* and returns AI-generated prose (36/1202 calls use this pattern).
+* `start_index`/`max_length` provide character-level pagination (~16 calls).
+* `raw` skips conversion entirely (1 call).
+*/
+const HEAD_LINES = 500;
+const TAIL_LINES = 500;
+const MAX_CHARS = 64e3;
+const CURL_TIMEOUT_SECS = 30;
+const MAX_REDIRECTS = 5;
+const CONFIG_DEFAULTS = {
+	model: "openrouter/google/gemini-3-flash-preview",
+	promptFile: "",
+	promptString: ""
+};
+const DEFAULT_PROMPT_SYSTEM = `Analyze web page content and answer questions. Be concise, answer from provided content only. No filler.`;
+function fetchUrl(url, signal) {
+	return new Promise((resolve) => {
+		const child = spawn("curl", [
+			"-sL",
+			"-H",
+			"Accept: text/markdown, text/html;q=0.9",
+			"-m",
+			String(CURL_TIMEOUT_SECS),
+			"--max-redirs",
+			String(MAX_REDIRECTS),
+			"-A",
+			"Mozilla/5.0 (compatible; pi-agent/1.0)",
+			url
+		], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		const output = new OutputBuffer(HEAD_LINES, TAIL_LINES);
+		let stderr = "";
+		let aborted = false;
+		const onAbort = () => {
+			aborted = true;
+			if (!child.killed) child.kill("SIGTERM");
+		};
+		if (signal) if (signal.aborted) onAbort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+		child.stdout?.on("data", (data) => {
+			output.add(data.toString("utf-8"));
+		});
+		child.stderr?.on("data", (data) => {
+			stderr += data.toString("utf-8");
+		});
+		child.on("error", (err) => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve({
+				html: "",
+				error: `curl error: ${err.message}`
+			});
+		});
+		child.on("close", (code) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (aborted) {
+				resolve({
+					html: "",
+					error: "fetch aborted"
+				});
+				return;
+			}
+			if (code !== 0) {
+				resolve({
+					html: "",
+					error: `fetch failed: ${stderr.trim() || `curl exited with code ${code}`}`
+				});
+				return;
+			}
+			const { text } = output.format();
+			resolve({ html: text });
+		});
+	});
+}
+function createReadWebPageTool(config = {}) {
+	return {
+		name: "read_web_page",
+		label: "Read Web Page",
+		description: "Read the contents of a web page at a given URL.\n\nReturns the page content converted to Markdown.\n\nWhen an objective is provided, it returns excerpts relevant to that objective.\n\nDo NOT use for localhost or local URLs — use `curl` via Bash instead.",
+		parameters: Type.Object({
+			url: Type.String({ description: "The URL of the web page to read." }),
+			objective: Type.Optional(Type.String({ description: "A natural-language description of the research goal. If set, only relevant excerpts will be returned. If not set, the full content is returned." })),
+			prompt: Type.Optional(Type.String({ description: "A question to answer about the page content. Spawns an AI sub-agent that reads the page and returns a prose answer." })),
+			start_index: Type.Optional(Type.Number({ description: "Character offset to start from in the converted content (for pagination)." })),
+			max_length: Type.Optional(Type.Number({ description: "Maximum number of characters to return (for pagination)." })),
+			raw: Type.Optional(Type.Boolean({ description: "Return raw HTML instead of converting to Markdown." })),
+			forceRefetch: Type.Optional(Type.Boolean({ description: "Force a live fetch (no caching). Currently always fetches live." }))
+		}),
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			const url = p.url;
+			if (!url.startsWith("http://") && !url.startsWith("https://")) return {
+				content: [{
+					type: "text",
+					text: `invalid URL: "${url}" — must start with http:// or https://`
+				}],
+				isError: true
+			};
+			const { html, error } = await fetchUrl(url, signal);
+			if (error) return {
+				content: [{
+					type: "text",
+					text: error
+				}],
+				isError: true
+			};
+			if (!html.trim()) return { content: [{
+				type: "text",
+				text: "(empty response)"
+			}] };
+			if (p.raw) return { content: [{
+				type: "text",
+				text: headTailChars(`Raw HTML content as requested:\n${html}`, MAX_CHARS).text
+			}] };
+			let content = htmlToMarkdown(html) ?? html;
+			if (p.start_index !== void 0 || p.max_length !== void 0) {
+				const total = content.length;
+				const start = p.start_index ?? 0;
+				const end = p.max_length !== void 0 ? start + p.max_length : total;
+				content = content.slice(start, end);
+				content += `\n\n[${start}–${Math.min(end, total)} of ${total} characters]`;
+			}
+			content = headTailChars(content, MAX_CHARS).text;
+			if (p.objective) content = `Objective: ${p.objective}\n\n---\n\n${content}`;
+			if (p.prompt) {
+				let sessionId = "";
+				try {
+					sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+				} catch {}
+				const task = `Here is the content of ${url}:\n\n${content}\n\n---\n\nAnswer this question: ${p.prompt}`;
+				const singleResult = {
+					agent: "read_web_page",
+					task: p.prompt,
+					exitCode: -1,
+					messages: [],
+					usage: zeroUsage()
+				};
+				const promptSystem = config.systemPrompt || DEFAULT_PROMPT_SYSTEM;
+				const result = await piSpawn({
+					cwd: ctx.cwd,
+					task,
+					model: config.model ?? CONFIG_DEFAULTS.model,
+					builtinTools: [],
+					extensionTools: [],
+					systemPromptBody: promptSystem,
+					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);
+			}
+			return { content: [{
+				type: "text",
+				text: content
+			}] };
+		},
+		renderCall(args, theme) {
+			const url = args.url || "...";
+			const displayUrl = url.length > 60 ? `${url.slice(0, 60)}...` : url;
+			const linkedUrl = url.startsWith("http") ? osc8Link(url, displayUrl) : displayUrl;
+			let text = theme.fg("toolTitle", theme.bold("read_web_page ")) + theme.fg("dim", linkedUrl);
+			const label = args.prompt || args.objective;
+			if (label) {
+				const short = label.length > 40 ? `${label.slice(0, 40)}...` : label;
+				text += theme.fg("muted", ` — ${short}`);
+			}
+			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: "read_web_page",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function read_web_page_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/read-web-page", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createReadWebPageTool({
+		systemPrompt: resolvePrompt(cfg.promptString, cfg.promptFile),
+		model: cfg.model
+	})));
+}
+//#endregion
+export { createReadWebPageTool, read_web_page_default as default };