@xl0/pi-lovely-web 0.2.1 → 0.2.2

package/README.md

@@ -38,7 +38,7 @@ The plain-text tool output looks like this:
    desc: Pi Coding Agent is a minimal, highly customizable terminal coding harness.
 ```
 
-- `web_fetch` - The single web page in markdown format
+- `web_fetch` - The single web page in markdown format. Set `findText` to an array of strings to return snippets from the fetched markdown. Optional `findMode` is `fuzzy` (default, normalized chunk match), `exact` (case-sensitive literal), or `lower` (case-insensitive literal). When smart search is enabled, set `smartQuery` to have a Pi text model answer/extract from the fetched markdown; `findText` and `smartQuery` can be combined.
 - `web_image` - The single image, returned as media content. Respects the Pi image resizing settings:
 
 ![web_image](https://raw.githubusercontent.com/xl0/pi-lovely-web/master/assets/web_image.png)
@@ -57,6 +57,10 @@ The settings are stored in `~/.pi/agent/xl0-pi-lovely-web.json` (global) or `.pi
   "webSearchProvider": "firecrawl",
   "webFetchProvider": "firecrawl",
   "webImageEnabled": true,
+  "smartSearchEnabled": false,
+  "smartSearchModel": "anthropic/claude-sonnet-4-5",
+  "smartSearchMaxTokens": 2000,
+  "smartSearchSystemPrompt": "Process one web_fetch result for a coding agent.\nUse only facts explicitly stated in the provided page text.\n...",
   "firecrawlApiKey": "fc-...",
   "exaApiKey": "...",
   "tavilyApiKey": "...",
@@ -68,6 +72,12 @@ API keys can also be set via environment variables: `FIRECRAWL_API_KEY`, `EXA_AP
 
 Search defaults to Firecrawl. Fetch defaults to `disabled`; configure `webFetchProvider` to enable `web_fetch` and `fetchResult:true` first-result fetches from `web_search`. Set `webSearchProvider` or `webFetchProvider` to `disabled` to remove that tool from Pi's active tool list. Set `webImageEnabled:false` to disable `web_image`.
 
+`web_fetch` also supports `findText`, an array of strings to search over fetched markdown. It returns deduped plain-text snippets with 500 characters of context; overlapping contexts are merged, each snippet lists matching queries and counts, UI rendering highlights hits, and returned snippets are capped to about 20k raw characters total. `findMode` defaults to `fuzzy`; `exact` preserves case, `lower` is case-insensitive literal, and `fuzzy` splits text on blank lines, normalizes accents/case/punctuation, scores chunks by query-token coverage plus typo-tolerant token matches, and highlights matched source tokens in the UI.
+
+When `smartSearchEnabled` is true, `smartQuery` post-processes `web_fetch` output with a Pi text model. It supports grounded summaries, extraction, comparisons, troubleshooting, limits/config/API details, security/migration notes, and verbatim code/command/schema examples. The prompt adapts the output format to the query, uses only explicitly stated page facts, preserves exact concrete fields, quotes/source-contexts important claims when useful without repeating the single fetched URL in every evidence bullet, and says `Not found on page.` for absent requested info. `/lovely-web` populates `smartSearchModel` from authenticated Pi text models and defaults to the current model when unset; invalid stored values warn and fall back to the default. `smartSearchSystemPrompt` defaults to the built-in prompt and can be edited. `findText` and `smartQuery` are independent: both read the raw fetched markdown and their outputs are concatenated.
+
+Smart input is limited to half the selected model context estimate. If model context is unknown, the fallback limit is about 60k estimated tokens. If input is trimmed, the tool result includes a visible note with kept/original character counts.
+
 Old `xl0-web-tools.json` configs are migrated to `xl0-pi-lovely-web.json` on load, then deleted.
 
 `web_search` and `web_fetch` parameters are provider-specific and update dynamically when you change providers. Changing providers changes the tool schema and potentially may confuse the model if you change the schema mid-session, but unlikely with modern LLMs.

package/extensions/lovely-web/command.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { ScopedConfigEditor } from "@xl0/pi-lovely-config"
 import { applyToolConfig, loadScopedConfig } from "./config.js"
 import { asErrorMessage } from "./format.js"
+import { resetSmartConfigState, validateSmartConfig } from "./smart.js"
 import { registerLovelyWebSearchTool, registerLovelyWebStaticTools } from "./tools.js"
 
 export function registerLovelyWebCommand(pi: ExtensionAPI) {
@@ -14,7 +15,7 @@ export function registerLovelyWebCommand(pi: ExtensionAPI) {
 			}
 
 			try {
-				const config = loadScopedConfig(ctx.cwd)
+				const config = loadScopedConfig(ctx.cwd, ctx)
 				notifyConfigWarnings(ctx, config.warnings)
 
 				await ctx.ui.custom<void>(
@@ -24,9 +25,11 @@ export function registerLovelyWebCommand(pi: ExtensionAPI) {
 							theme,
 							config,
 							onChange(config) {
-								registerLovelyWebSearchTool(pi, config.value)
-								registerLovelyWebStaticTools(pi, config.value)
-								applyToolConfig(pi, config.value)
+								resetSmartConfigState()
+								const value = validateSmartConfig(config.value, ctx) ? config.value : { ...config.value, smartSearchEnabled: false }
+								registerLovelyWebSearchTool(pi, value)
+								registerLovelyWebStaticTools(pi, value)
+								applyToolConfig(pi, value)
 							},
 							done
 						})

package/extensions/lovely-web/config.ts

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync, rmSync } from "node:fs"
 import { dirname, join } from "node:path"
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { type ConfigFromSchema, defineScopedConfig, field } from "@xl0/pi-lovely-config"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { type ConfigFromSchema, defineScopedConfig, field, type ScopedConfig } from "@xl0/pi-lovely-config"
 import { braveProvider } from "./providers/brave.js"
 import { exaProvider } from "./providers/exa.js"
 import { firecrawlProvider } from "./providers/firecrawl.js"
 import { tavilyProvider } from "./providers/tavily.js"
 import type { Provider } from "./providers/types.js"
+import { SMART_SYSTEM_PROMPT } from "./smart.js"
 
 export const DEFAULT_PROVIDER_ID = "firecrawl"
 export const CONFIG_FILE_NAME = "xl0-pi-lovely-web.json"
@@ -17,6 +18,7 @@ const searchProviderValues = ["firecrawl", "exa", "tavily", "brave"] as const
 const fetchProviderValues = ["firecrawl", "exa", "tavily"] as const
 const searchProviderSettingValues = [DISABLED_VALUE, ...searchProviderValues] as const
 const fetchProviderSettingValues = [DISABLED_VALUE, ...fetchProviderValues] as const
+type SmartModelConfigContext = Pick<ExtensionContext, "model" | "modelRegistry">
 
 export const providers: Record<string, Provider> = {
 	firecrawl: firecrawlProvider,
@@ -32,45 +34,102 @@ const apiKeyFields = {
 	brave: "braveApiKey"
 } as const
 
-const lovelyWebConfigSchema = {
-	webSearchProvider: field.enum(searchProviderSettingValues, DEFAULT_PROVIDER_ID, {
-		label: "web_search",
-		description: "Search provider, or disabled to remove web_search from active tools."
-	}),
-	webFetchProvider: field.enum(fetchProviderSettingValues, DISABLED_VALUE, {
-		label: "web_fetch",
-		description: "Fetch provider, or disabled to remove web_fetch from active tools."
-	}),
-	webImageEnabled: field.boolean(true, {
-		label: "web_image",
-		description: "Enable or disable direct image URL fetching."
-	}),
-	webImageResize: field.boolean(true, {
-		label: "Resize images",
-		description: "Resize fetched images to fit within the max size limit.",
-		depth: 1,
-		visibleWhen: ({ get }) => get("webImageEnabled") === true
-	}),
-	webImageMaxSize: field.number(2000, {
-		label: "Max image size",
-		description: "Maximum longest side in pixels for resized images.",
-		min: 1,
-		step: 100,
+function modelId(model: ExtensionContext["model"]): string | undefined {
+	return model ? `${model.provider}/${model.id}` : undefined
+}
+
+function smartSearchModelField(ctx?: SmartModelConfigContext) {
+	const availableModels = ctx?.modelRegistry.getAvailable().filter(model => model.input.includes("text")) ?? []
+	const [firstModelId, ...otherModelIds] = availableModels.map(model => `${model.provider}/${model.id}`)
+	if (firstModelId === undefined) {
+		return field.string("", {
+			label: "Smart search model",
+			description: "Text model as provider/model. No authenticated text models are currently available.",
+			depth: 1,
+			visibleWhen: ({ get }) => get("smartSearchEnabled") === true
+		})
+	}
+
+	const modelValues = [firstModelId, ...otherModelIds] as [string, ...string[]]
+	const currentModelId = modelId(ctx?.model)
+	const defaultModel = currentModelId && modelValues.includes(currentModelId) ? currentModelId : modelValues[0]
+	const valueDescriptions = Object.fromEntries(availableModels.map(model => [`${model.provider}/${model.id}`, model.name || model.id]))
+	return field.enum(modelValues, defaultModel, {
+		label: "Smart search model",
+		description: "Pi text model for smartQuery post-processing.",
+		search: true,
+		valueDescriptions,
 		depth: 1,
-		visibleWhen: ({ get }) => get("webImageEnabled") === true && get("webImageResize") === true
-	}),
-	firecrawlApiKey: field.string("", { label: "Firecrawl API key" }),
-	exaApiKey: field.string("", { label: "Exa API key" }),
-	tavilyApiKey: field.string("", { label: "Tavily API key" }),
-	braveApiKey: field.string("", { label: "Brave API key" })
-} as const
+		visibleWhen: ({ get }) => get("smartSearchEnabled") === true
+	})
+}
+
+function createLovelyWebConfigSchema(ctx?: SmartModelConfigContext) {
+	return {
+		webSearchProvider: field.enum(searchProviderSettingValues, DEFAULT_PROVIDER_ID, {
+			label: "web_search",
+			description: "Search provider, or disabled to remove web_search from active tools."
+		}),
+		webFetchProvider: field.enum(fetchProviderSettingValues, DISABLED_VALUE, {
+			label: "web_fetch",
+			description: "Fetch provider, or disabled to remove web_fetch from active tools."
+		}),
+		webImageEnabled: field.boolean(true, {
+			label: "web_image",
+			description: "Enable or disable direct image URL fetching."
+		}),
+		webImageResize: field.boolean(true, {
+			label: "Resize images",
+			description: "Resize fetched images to fit within the max size limit.",
+			depth: 1,
+			visibleWhen: ({ get }) => get("webImageEnabled") === true
+		}),
+		webImageMaxSize: field.number(2000, {
+			label: "Max image size",
+			description: "Maximum longest side in pixels for resized images.",
+			min: 1,
+			step: 100,
+			depth: 1,
+			visibleWhen: ({ get }) => get("webImageEnabled") === true && get("webImageResize") === true
+		}),
+		smartSearchEnabled: field.boolean(false, {
+			label: "Smart search",
+			description: "Enable smartQuery post-processing for web_fetch."
+		}),
+		smartSearchModel: smartSearchModelField(ctx),
+		smartSearchMaxTokens: field.number(2000, {
+			label: "Smart search max tokens",
+			description: "Maximum output tokens for smartQuery post-processing.",
+			min: 1,
+			step: 100,
+			depth: 1,
+			visibleWhen: ({ get }) => get("smartSearchEnabled") === true
+		}),
+		smartSearchSystemPrompt: field.text(SMART_SYSTEM_PROMPT, {
+			label: "Smart search system prompt",
+			description: "System prompt for smartQuery post-processing. Unset to use the built-in default.",
+			depth: 1,
+			visibleWhen: ({ get }) => get("smartSearchEnabled") === true
+		}),
+		firecrawlApiKey: field.string("", { label: "Firecrawl API key" }),
+		exaApiKey: field.string("", { label: "Exa API key" }),
+		tavilyApiKey: field.string("", { label: "Tavily API key" }),
+		braveApiKey: field.string("", { label: "Brave API key" })
+	} as const
+}
+
+const lovelyWebConfigSchema = createLovelyWebConfigSchema()
 
 export type WebToolsConfig = ConfigFromSchema<typeof lovelyWebConfigSchema>
 
-export const lovelyWebConfigSpec = defineScopedConfig({
-	fileName: CONFIG_FILE_NAME,
-	schema: lovelyWebConfigSchema
-})
+export const lovelyWebConfigSpec = createLovelyWebConfigSpec()
+
+export function createLovelyWebConfigSpec(ctx?: SmartModelConfigContext): ScopedConfig<WebToolsConfig> {
+	return defineScopedConfig({
+		fileName: CONFIG_FILE_NAME,
+		schema: createLovelyWebConfigSchema(ctx)
+	}) as ScopedConfig<WebToolsConfig>
+}
 
 export function isSearchEnabled(config: WebToolsConfig): boolean {
 	return config.webSearchProvider !== DISABLED_VALUE
@@ -124,12 +183,12 @@ export function resolveApiKey(provider: Provider, config: WebToolsConfig): strin
 	throw new Error(`No API key for ${provider.label}. Set it via /lovely-web or set the ${provider.envApiKey} environment variable.`)
 }
 
-export function loadConfig(cwd: string): WebToolsConfig {
-	return loadScopedConfig(cwd).value
+export function loadConfig(cwd: string, ctx?: SmartModelConfigContext): WebToolsConfig {
+	return loadScopedConfig(cwd, ctx).value
 }
 
-export function loadScopedConfig(cwd: string): typeof lovelyWebConfigSpec {
-	const config = lovelyWebConfigSpec.load(cwd)
+export function loadScopedConfig(cwd: string, ctx?: SmartModelConfigContext): ScopedConfig<WebToolsConfig> {
+	const config = createLovelyWebConfigSpec(ctx).load(cwd)
 	migrateOldConfig(config)
 	return config
 }
@@ -152,7 +211,7 @@ type OldConfig = {
 	webApiKeys?: Record<string, string>
 }
 
-function migrateOldConfig(config: typeof lovelyWebConfigSpec): void {
+function migrateOldConfig(config: ScopedConfig<WebToolsConfig>): void {
 	for (const scope of config.scopes) {
 		const newPath = config.path(scope)
 		const oldPath = join(dirname(newPath), OLD_CONFIG_FILE_NAME)

package/extensions/lovely-web/find.ts

@@ -0,0 +1,356 @@
+export type FindMode = "exact" | "lower" | "fuzzy"
+
+export const FIND_HIGHLIGHT_START = "\uE000"
+export const FIND_HIGHLIGHT_END = "\uE001"
+
+const FIND_TEXT_CONTEXT_CHARS = 500
+const FIND_TEXT_SNIPPET_CHARS = FIND_TEXT_CONTEXT_CHARS * 2
+const FIND_TEXT_MAX_CHARS = FIND_TEXT_SNIPPET_CHARS * 20
+
+interface SnippetRange {
+	start: number
+	end: number
+}
+
+interface TextMatch {
+	query: string
+	index: number
+	length: number
+	highlights?: SnippetRange[]
+}
+
+interface FindSnippet extends SnippetRange {
+	matches: TextMatch[]
+}
+
+interface TextToken extends SnippetRange {
+	normalized: string
+}
+
+interface OffsetMappedText {
+	text: string
+	offsets: SnippetRange[]
+}
+
+function compactSnippetPart(text: string): string {
+	return text.replace(/\s+/g, " ").trim()
+}
+
+function snippetRange(text: string, index: number, length: number): SnippetRange {
+	return {
+		start: Math.max(0, index - FIND_TEXT_CONTEXT_CHARS),
+		end: Math.min(text.length, index + length + FIND_TEXT_CONTEXT_CHARS)
+	}
+}
+
+function mergeRanges(ranges: SnippetRange[]): SnippetRange[] {
+	const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end)
+	const merged: SnippetRange[] = []
+	for (const range of sorted) {
+		const last = merged.at(-1)
+		if (!last || range.start > last.end) merged.push({ ...range })
+		else last.end = Math.max(last.end, range.end)
+	}
+	return merged
+}
+
+function mergeMatchesIntoSnippets(text: string, matches: TextMatch[]): FindSnippet[] {
+	const sorted = [...matches].sort((a, b) => a.index - b.index || a.query.localeCompare(b.query))
+	const merged: FindSnippet[] = []
+	for (const match of sorted) {
+		const range = snippetRange(text, match.index, match.length)
+		const last = merged.at(-1)
+		if (!last || range.start > last.end) merged.push({ ...range, matches: [match] })
+		else {
+			last.end = Math.max(last.end, range.end)
+			last.matches.push(match)
+		}
+	}
+	return merged
+}
+
+function matchHighlights(match: TextMatch): SnippetRange[] {
+	return match.highlights ?? [{ start: match.index, end: match.index + match.length }]
+}
+
+function formatPlainSnippet(text: string, snippet: FindSnippet): string {
+	return `${snippet.start > 0 ? "…" : ""}${compactSnippetPart(text.slice(snippet.start, snippet.end))}${snippet.end < text.length ? "…" : ""}`.trim()
+}
+
+function formatMarkedSnippet(text: string, snippet: FindSnippet): string {
+	const highlights = mergeRanges(
+		snippet.matches
+			.flatMap(match => matchHighlights(match))
+			.map(range => ({ start: Math.max(snippet.start, range.start), end: Math.min(snippet.end, range.end) }))
+			.filter(range => range.end > range.start)
+	)
+
+	let cursor = snippet.start
+	let marked = ""
+	for (const range of highlights) {
+		marked += text.slice(cursor, range.start)
+		marked += `${FIND_HIGHLIGHT_START}${text.slice(range.start, range.end)}${FIND_HIGHLIGHT_END}`
+		cursor = range.end
+	}
+	marked += text.slice(cursor, snippet.end)
+	return `${snippet.start > 0 ? "…" : ""}${compactSnippetPart(marked)}${snippet.end < text.length ? "…" : ""}`.trim()
+}
+
+function normalizeFindText(text: string): string {
+	return text
+		.normalize("NFD")
+		.replace(/\p{Diacritic}/gu, "")
+		.toLocaleLowerCase()
+}
+
+function lowerWithOffsetMap(text: string): OffsetMappedText {
+	let loweredText = ""
+	const offsets: SnippetRange[] = []
+	let index = 0
+	for (const char of text) {
+		const lowered = char.toLocaleLowerCase()
+		const end = index + char.length
+		loweredText += lowered
+		for (let i = 0; i < lowered.length; i++) offsets.push({ start: index, end })
+		index = end
+	}
+	return { text: loweredText, offsets }
+}
+
+function normalizeQuery(text: string): string {
+	return normalizeFindText(text)
+		.replace(/[^\p{L}\p{N}]+/gu, " ")
+		.replace(/\s+/g, " ")
+		.trim()
+}
+
+function tokenize(text: string, baseStart = 0): TextToken[] {
+	const tokens: TextToken[] = []
+	const re = /[\p{L}\p{N}]+/gu
+	let match = re.exec(text)
+	while (match) {
+		const raw = match[0]
+		const normalized = normalizeFindText(raw)
+		if (normalized) tokens.push({ normalized, start: baseStart + match.index, end: baseStart + match.index + raw.length })
+		match = re.exec(text)
+	}
+	return tokens
+}
+
+function cappedEditDistance(a: string, b: string, max: number): number {
+	if (Math.abs(a.length - b.length) > max) return max + 1
+	let prev = Array.from({ length: b.length + 1 }, (_, i) => i)
+	for (let i = 1; i <= a.length; i++) {
+		const curr = [i]
+		let rowMin = curr[0] ?? 0
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1
+			const value = Math.min((prev[j] ?? 0) + 1, (curr[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost)
+			curr[j] = value
+			rowMin = Math.min(rowMin, value)
+		}
+		if (rowMin > max) return max + 1
+		prev = curr
+	}
+	return prev[b.length] ?? max + 1
+}
+
+function fuzzyTokenMatches(token: string, chunkToken: string): boolean {
+	if (chunkToken === token) return true
+	if (/\d/.test(token)) return false
+	if (token.length < 6) return false
+	const maxDistance = token.length <= 8 ? 1 : 2
+	return Math.abs(token.length - chunkToken.length) <= maxDistance && cappedEditDistance(token, chunkToken, maxDistance) <= maxDistance
+}
+
+function matchingQueryIndexes(token: string, queryTokens: string[]): number[] {
+	return queryTokens.flatMap((queryToken, index) => (fuzzyTokenMatches(queryToken, token) ? [index] : []))
+}
+
+function selectFuzzyWindow(tokens: TextToken[], queryTokens: string[], maxSpan: number): { tokens: TextToken[]; coverage: number } {
+	const candidates = tokens
+		.map(token => ({ token, queryIndexes: matchingQueryIndexes(token.normalized, queryTokens) }))
+		.filter(candidate => candidate.queryIndexes.length > 0)
+	const minCoverage = queryTokens.length === 1 ? 1 : Math.ceil(queryTokens.length * 0.6)
+	for (let target = queryTokens.length; target >= minCoverage; target--) {
+		const counts = new Map<number, number>()
+		let unique = 0
+		let left = 0
+		let best: { left: number; right: number; span: number } | undefined
+		for (let right = 0; right < candidates.length; right++) {
+			for (const queryIndex of candidates[right]?.queryIndexes ?? []) {
+				const count = counts.get(queryIndex) ?? 0
+				if (count === 0) unique++
+				counts.set(queryIndex, count + 1)
+			}
+			while (unique >= target) {
+				const leftToken = candidates[left]?.token
+				const rightToken = candidates[right]?.token
+				if (leftToken && rightToken) {
+					const span = rightToken.end - leftToken.start
+					if (!best || span < best.span) best = { left, right, span }
+				}
+				for (const queryIndex of candidates[left]?.queryIndexes ?? []) {
+					const count = (counts.get(queryIndex) ?? 0) - 1
+					if (count === 0) {
+						counts.delete(queryIndex)
+						unique--
+					} else counts.set(queryIndex, count)
+				}
+				left++
+			}
+		}
+		if (best && best.span <= maxSpan) {
+			return {
+				tokens: candidates.slice(best.left, best.right + 1).map(candidate => candidate.token),
+				coverage: target / queryTokens.length
+			}
+		}
+	}
+	return { tokens: [], coverage: 0 }
+}
+
+function splitChunks(text: string): Array<{ text: string; start: number }> {
+	const chunks: Array<{ text: string; start: number }> = []
+	const re = /\n\s*\n+/g
+	let start = 0
+	let match = re.exec(text)
+	while (match) {
+		const chunkText = text.slice(start, match.index)
+		const trimmed = chunkText.trim()
+		const firstNonSpace = chunkText.search(/\S/)
+		if (trimmed.length > 20 && firstNonSpace >= 0) chunks.push({ text: trimmed, start: start + firstNonSpace })
+		start = re.lastIndex
+		match = re.exec(text)
+	}
+	const chunkText = text.slice(start)
+	const trimmed = chunkText.trim()
+	const firstNonSpace = chunkText.search(/\S/)
+	if (trimmed.length > 20 && firstNonSpace >= 0) chunks.push({ text: trimmed, start: start + firstNonSpace })
+	return chunks
+}
+
+function snippetChars(range: SnippetRange): number {
+	return range.end - range.start
+}
+
+function clipSnippet(snippet: FindSnippet, maxChars: number): FindSnippet | undefined {
+	const end = Math.min(snippet.end, snippet.start + maxChars)
+	const matches = snippet.matches.filter(match => match.index < end && match.index + match.length > snippet.start)
+	return matches.length > 0 ? { start: snippet.start, end, matches } : undefined
+}
+
+function countQueries(matches: TextMatch[]): Array<{ query: string; count: number }> {
+	const counts = new Map<string, number>()
+	for (const match of matches) counts.set(match.query, (counts.get(match.query) ?? 0) + 1)
+	return [...counts].map(([query, count]) => ({ query, count }))
+}
+
+function formatQueryCounts(matches: TextMatch[]): string {
+	return countQueries(matches)
+		.map(({ query, count }) => `"${query}" ×${count}`)
+		.join(", ")
+}
+
+function collectLiteralMatches(text: string, query: string, mode: "exact" | "lower"): TextMatch[] {
+	const needle = query.trim()
+	const lowered = mode === "lower" ? lowerWithOffsetMap(text) : undefined
+	const haystack = lowered?.text ?? text
+	const searchNeedle = mode === "exact" ? needle : needle.toLocaleLowerCase()
+	const matches: TextMatch[] = []
+	let index = searchNeedle ? haystack.indexOf(searchNeedle) : -1
+	while (index !== -1) {
+		const start = lowered?.offsets[index]?.start ?? index
+		const end = lowered?.offsets[index + searchNeedle.length - 1]?.end ?? index + needle.length
+		matches.push({ query: needle, index: start, length: end - start })
+		index = haystack.indexOf(searchNeedle, index + searchNeedle.length)
+	}
+	return matches
+}
+
+function collectFuzzyMatches(text: string, query: string): TextMatch[] {
+	const normalizedQuery = normalizeQuery(query)
+	const queryTokens = [...new Set(normalizedQuery.split(" ").filter(token => token.length >= 2))].slice(0, 20)
+	if (queryTokens.length === 0) return []
+	const maxSpan = queryTokens.length <= 2 ? Math.max(60, normalizedQuery.length * 3) : Math.max(30, queryTokens.join(" ").length * 2)
+
+	return splitChunks(text)
+		.map(chunk => {
+			const tokens = tokenize(chunk.text, chunk.start)
+			const normalizedChunk = tokens.map(token => token.normalized).join(" ")
+			const phraseHit = normalizedChunk.includes(queryTokens.join(" "))
+			const window = selectFuzzyWindow(tokens, queryTokens, maxSpan)
+			const matchedTokens = window.tokens
+			const coverage = window.coverage
+			return { chunk, matchedTokens, phraseHit, coverage, score: coverage + (phraseHit ? 1 : 0) }
+		})
+		.filter(match => match.phraseHit || (queryTokens.length === 1 ? match.coverage > 0 : match.coverage >= 0.6))
+		.sort((a, b) => b.score - a.score || a.chunk.start - b.chunk.start)
+		.map(match => {
+			const highlights = mergeRanges(match.matchedTokens.map(token => ({ start: token.start, end: token.end })))
+			const start = highlights[0]?.start ?? match.chunk.start
+			const end = highlights.at(-1)?.end ?? Math.min(text.length, match.chunk.start + 80)
+			return { query, index: start, length: end - start, highlights }
+		})
+}
+
+export function formatFindTextMatches(
+	text: string,
+	queries: string[],
+	mode: FindMode
+): { text: string; renderText: string; details: unknown } {
+	const trimmedQueries = queries.map(query => query.trim()).filter(Boolean)
+	const matches = trimmedQueries.flatMap(query =>
+		mode === "fuzzy" ? collectFuzzyMatches(text, query) : collectLiteralMatches(text, query, mode)
+	)
+	const queryResults = trimmedQueries.map(query => ({ query, matchCount: matches.filter(match => match.query === query).length }))
+	const snippets = mergeMatchesIntoSnippets(text, matches)
+	const selected: FindSnippet[] = []
+	let charsUsed = 0
+	for (const snippet of snippets) {
+		const remaining = FIND_TEXT_MAX_CHARS - charsUsed
+		if (remaining <= 0) break
+		const chars = snippetChars(snippet)
+		if (chars <= remaining) {
+			selected.push(snippet)
+			charsUsed += chars
+			continue
+		}
+		const clipped = clipSnippet(snippet, remaining)
+		if (clipped) {
+			selected.push(clipped)
+			charsUsed += snippetChars(clipped)
+		}
+		break
+	}
+	const shownMatches = selected.reduce((sum, snippet) => sum + snippet.matches.length, 0)
+	const noMatchQueries = queryResults.filter(result => result.matchCount === 0).map(result => `"${result.query}"`)
+	const title = matches.length ? `Text matches (${mode}):` : `Text matches (${mode}): no matches`
+	const body = selected.map((snippet, i) => `${i + 1}. ${formatQueryCounts(snippet.matches)}\n${formatPlainSnippet(text, snippet)}`)
+	const renderBody = selected.map((snippet, i) => `${i + 1}. ${formatQueryCounts(snippet.matches)}\n${formatMarkedSnippet(text, snippet)}`)
+	const noMatches = noMatchQueries.length ? `No matches: ${noMatchQueries.join(", ")}` : undefined
+	if (noMatches) {
+		body.push(noMatches)
+		renderBody.push(noMatches)
+	}
+	return {
+		text: body.length ? `${title}\n\n${body.join("\n\n")}` : title,
+		renderText: renderBody.length ? `${title}\n\n${renderBody.join("\n\n")}` : title,
+		details: {
+			mode,
+			contextChars: FIND_TEXT_CONTEXT_CHARS,
+			snippetChars: FIND_TEXT_SNIPPET_CHARS,
+			maxChars: FIND_TEXT_MAX_CHARS,
+			charsUsed,
+			matchCount: matches.length,
+			returnedMatches: shownMatches,
+			queryResults,
+			snippets: selected.map(snippet => ({
+				start: snippet.start,
+				end: snippet.end,
+				chars: snippetChars(snippet),
+				matches: countQueries(snippet.matches)
+			}))
+		}
+	}
+}

package/extensions/lovely-web/image.ts

@@ -1,7 +1,6 @@
-import { formatDimensionNote, type ResizedImage, resizeImage } from "@earendil-works/pi-coding-agent"
+import { type AgentToolResult, formatDimensionNote, type ResizedImage, resizeImage } from "@earendil-works/pi-coding-agent"
 import { getImageDimensions } from "@earendil-works/pi-tui"
 import { DEFAULT_TIMEOUT_MS } from "./constants.js"
-import type { ToolResult } from "./types.js"
 
 export const DEFAULT_MAX_IMAGE_BYTES = 5_000_000
 export const MAX_IMAGE_BYTES = 20_000_000
@@ -63,11 +62,11 @@ async function fetchImageContent(
 	}
 }
 
-function textOnlyResult(text: string, details: Record<string, unknown>): ToolResult {
+function textOnlyResult(text: string, details: Record<string, unknown>): AgentToolResult<unknown> {
 	return { content: [{ type: "text" as const, text }], details }
 }
 
-function imageResult(text: string, image: { data: string; mimeType: string }, details: Record<string, unknown>): ToolResult {
+function imageResult(text: string, image: { data: string; mimeType: string }, details: Record<string, unknown>): AgentToolResult<unknown> {
 	return {
 		content: [
 			{ type: "text" as const, text },
@@ -77,7 +76,7 @@ function imageResult(text: string, image: { data: string; mimeType: string }, de
 	}
 }
 
-function emitResult(result: ToolResult, onUpdate?: (result: ToolResult) => void): ToolResult {
+function emitResult(result: AgentToolResult<unknown>, onUpdate?: (result: AgentToolResult<unknown>) => void): AgentToolResult<unknown> {
 	onUpdate?.(result)
 	return result
 }
@@ -91,8 +90,8 @@ export async function imageImpl(
 		maxSize?: number | undefined
 	},
 	signal?: AbortSignal,
-	onUpdate?: (result: ToolResult) => void
-): Promise<ToolResult> {
+	onUpdate?: (result: AgentToolResult<unknown>) => void
+): Promise<AgentToolResult<unknown>> {
 	const maxBytes = params.maxBytes ?? DEFAULT_MAX_IMAGE_BYTES
 	if (maxBytes > MAX_IMAGE_BYTES) throw new Error(`maxBytes cannot exceed ${MAX_IMAGE_BYTES}`)
 

package/extensions/lovely-web/index.ts

@@ -2,17 +2,20 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import { registerLovelyWebCommand } from "./command.js"
 import { applyToolConfig, loadScopedConfig } from "./config.js"
 import { asErrorMessage } from "./format.js"
+import { resetSmartRuntimeState, validateSmartConfig } from "./smart.js"
 import { registerLovelyWebSearchTool, registerLovelyWebStaticTools } from "./tools.js"
 
 export default function (pi: ExtensionAPI) {
 	registerLovelyWebStaticTools(pi)
 	pi.on("session_start", async (_event, ctx) => {
 		try {
-			const loaded = loadScopedConfig(ctx.cwd)
+			resetSmartRuntimeState()
+			const loaded = loadScopedConfig(ctx.cwd, ctx)
 			if (loaded.warnings.length > 0) ctx.ui.notify(loaded.warnings.map(w => `${w.path}: ${w.message}`).join("\n"), "warning")
-			registerLovelyWebSearchTool(pi, loaded.value)
-			registerLovelyWebStaticTools(pi, loaded.value)
-			applyToolConfig(pi, loaded.value)
+			const config = validateSmartConfig(loaded.value, ctx) ? loaded.value : { ...loaded.value, smartSearchEnabled: false }
+			registerLovelyWebSearchTool(pi, config)
+			registerLovelyWebStaticTools(pi, config)
+			applyToolConfig(pi, config)
 		} catch (error) {
 			ctx.ui.notify(`Lovely Web config error: ${asErrorMessage(error)}`, "error")
 		}

package/extensions/lovely-web/render.ts

@@ -1,10 +1,11 @@
 import type { Theme } from "@earendil-works/pi-coding-agent"
 import { Text } from "@earendil-works/pi-tui"
+import { FIND_HIGHLIGHT_END, FIND_HIGHLIGHT_START } from "./find.js"
 
 const COLLAPSED_RESULT_LINES = 6
 
 export function renderTextResult(
-	result: { content: Array<{ type: string; text?: string }> },
+	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
 	expanded: boolean,
 	theme: Theme,
 	partialLabel: string
@@ -13,11 +14,36 @@ export function renderTextResult(
 	if (content?.type !== "text" || content.text === undefined) return new Text(theme.fg("error", "No text output"), 0, 0)
 	if (!content.text.trim()) return new Text(theme.fg("dim", partialLabel), 0, 0)
 
-	const lines = content.text.split("\n")
+	const renderText = renderTextOverride(result.details) ?? content.text
+	const lines = renderText.split("\n")
 	const shown = expanded ? lines : lines.slice(0, COLLAPSED_RESULT_LINES)
-	let text = shown.map(line => theme.fg("toolOutput", line)).join("\n")
+	let text = shown.map(line => renderHighlightMarkers(line, theme)).join("\n")
 	if (!expanded && lines.length > COLLAPSED_RESULT_LINES) {
 		text += `\n${theme.fg("muted", `... ${lines.length - COLLAPSED_RESULT_LINES} more lines (ctrl-o to expand)`)}`
 	}
 	return new Text(text, 0, 0)
 }
+
+function renderTextOverride(details: unknown): string | undefined {
+	if (!details || typeof details !== "object") return undefined
+	const renderText = (details as { renderText?: unknown }).renderText
+	return typeof renderText === "string" ? renderText : undefined
+}
+
+function renderHighlightMarkers(line: string, theme: Theme): string {
+	let rest = line
+	let output = ""
+	while (true) {
+		const start = rest.indexOf(FIND_HIGHLIGHT_START)
+		if (start === -1) return output + theme.fg("toolOutput", stripHighlightMarkers(rest))
+		const end = rest.indexOf(FIND_HIGHLIGHT_END, start + FIND_HIGHLIGHT_START.length)
+		if (end === -1) return output + theme.fg("toolOutput", stripHighlightMarkers(rest))
+		output += theme.fg("toolOutput", rest.slice(0, start))
+		output += theme.bold(theme.fg("accent", rest.slice(start + FIND_HIGHLIGHT_START.length, end)))
+		rest = rest.slice(end + FIND_HIGHLIGHT_END.length)
+	}
+}
+
+function stripHighlightMarkers(text: string): string {
+	return text.replaceAll(FIND_HIGHLIGHT_START, "").replaceAll(FIND_HIGHLIGHT_END, "")
+}

package/extensions/lovely-web/smart.ts

@@ -0,0 +1,197 @@
+import { type Api, type AssistantMessage, completeSimple, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai"
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
+import type { WebToolsConfig } from "./config.js"
+
+const SMART_INPUT_FALLBACK_CHARS = 60_000 * 3
+
+export const SMART_SYSTEM_PROMPT = `Process one web_fetch result for a coding agent.
+Use only facts explicitly stated in the provided page text.
+Answer the smart query, not the whole page. Include neighboring/related sections only when needed for the requested task.
+
+Return concise Markdown in the format that best fits the query:
+- If the query asks for a specific format, use it.
+- For verbatim code, commands, schemas, examples, config, or error text, return the requested excerpt first, exactly as written, preserving indentation and punctuation.
+- For summaries, focus on what a coding agent needs: purpose, setup, APIs/options, steps, limits, caveats, security notes, migration/breaking changes, and gotchas that are directly stated.
+- For extraction/comparison, use bullet points, preserve exact names, signatures, flags, codes, amounts, dates, deadlines, defaults, and version/platform caveats.
+- For troubleshooting, include directly stated symptoms, causes, fixes/workarounds, and warnings.
+
+Grounding rules:
+- Include short exact quotes or source context for important claims unless the answer is only a verbatim excerpt.
+- There is one fetched page; use a heading like "Evidence (on this page):" for an evidence section. 
+- If requested information is absent or partially absent, say "Not found on page." Mention missing fields under a short Missing section when useful.
+- Use "None" only when the page explicitly supports it or the query only asks whether requested fields were found.
+- For legal/admin pages, state only what the page says and flag when exact amounts/codes require a calculator, form, or agency confirmation.`
+
+let warnedDefaultModel = false
+let warnedUnavailableModel = false
+let disabledForSession = false
+
+export interface SmartProcessInput {
+	query: string
+	resultText: string
+	sourceUrl?: string
+}
+
+export interface SmartProcessResult {
+	text: string
+	details: {
+		query: string
+		model: string
+		inputChars: number
+		originalInputChars: number
+		maxInputChars: number
+		truncated: boolean
+		stopReason: AssistantMessage["stopReason"]
+		usage: AssistantMessage["usage"]
+	}
+}
+
+export function resetSmartRuntimeState(): void {
+	warnedDefaultModel = false
+	warnedUnavailableModel = false
+	disabledForSession = false
+}
+
+export function resetSmartConfigState(): void {
+	warnedUnavailableModel = false
+	disabledForSession = false
+}
+
+function modelName(model: Model<Api>): string {
+	return `${model.provider}/${model.id}`
+}
+
+function warn(ctx: ExtensionContext, message: string): void {
+	ctx.ui.notify(message, "warning")
+}
+
+function disableSmart(ctx: ExtensionContext, reason: string): void {
+	disabledForSession = true
+	if (warnedUnavailableModel) return
+	warnedUnavailableModel = true
+	warn(ctx, `Lovely Web smart search disabled: ${reason}`)
+}
+
+function resolveConfiguredModel(ctx: ExtensionContext, configured: string): Model<Api> | undefined {
+	const separator = configured.indexOf("/")
+	if (separator <= 0 || separator === configured.length - 1) {
+		disableSmart(ctx, `configured model must be "provider/model", got "${configured}".`)
+		return undefined
+	}
+
+	const provider = configured.slice(0, separator)
+	const modelId = configured.slice(separator + 1)
+	const model = ctx.modelRegistry.getAvailable().find(model => model.provider === provider && model.id === modelId)
+	if (!model) {
+		disableSmart(ctx, `configured model unavailable: ${configured}`)
+		return undefined
+	}
+	if (!model.input.includes("text")) {
+		disableSmart(ctx, `configured model does not support text input: ${configured}`)
+		return undefined
+	}
+	return model
+}
+
+function resolveCurrentModel(ctx: ExtensionContext): Model<Api> | undefined {
+	const model = ctx.model
+	if (!model) {
+		disableSmart(ctx, "no current model is selected.")
+		return undefined
+	}
+	if (!model.input.includes("text")) {
+		disableSmart(ctx, `current model does not support text input: ${modelName(model)}.`)
+		return undefined
+	}
+	if (!warnedDefaultModel) {
+		warnedDefaultModel = true
+		warn(ctx, `Lovely Web smart search model not selected; using current model ${modelName(model)}.`)
+	}
+	return model
+}
+
+function resolveSmartModel(config: WebToolsConfig, ctx: ExtensionContext): Model<Api> | undefined {
+	if (!config.smartSearchEnabled || disabledForSession) return undefined
+	const configured = config.smartSearchModel.trim()
+	return configured ? resolveConfiguredModel(ctx, configured) : resolveCurrentModel(ctx)
+}
+
+export function validateSmartConfig(config: WebToolsConfig, ctx: ExtensionContext): boolean {
+	if (!config.smartSearchEnabled) return true
+	return resolveSmartModel(config, ctx) !== undefined
+}
+
+function truncateForModel(text: string, model: Model<Api>): { text: string; originalChars: number; maxChars: number; truncated: boolean } {
+	const maxChars = model.contextWindow > 0 ? Math.max(4000, Math.floor((model.contextWindow / 2) * 3)) : SMART_INPUT_FALLBACK_CHARS
+	if (text.length <= maxChars) return { text, originalChars: text.length, maxChars, truncated: false }
+	return { text: text.slice(0, maxChars), originalChars: text.length, maxChars, truncated: true }
+}
+
+function extractText(message: AssistantMessage): string {
+	return message.content
+		.filter((item): item is { type: "text"; text: string } => item.type === "text")
+		.map(item => item.text)
+		.join("\n")
+		.trim()
+}
+
+function smartSystemPrompt(config: WebToolsConfig): string {
+	return config.smartSearchSystemPrompt.trim() ? config.smartSearchSystemPrompt : SMART_SYSTEM_PROMPT
+}
+
+export async function smartProcess(
+	config: WebToolsConfig,
+	ctx: ExtensionContext,
+	input: SmartProcessInput,
+	signal?: AbortSignal
+): Promise<SmartProcessResult | undefined> {
+	const model = resolveSmartModel(config, ctx)
+	if (!model) return undefined
+
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model)
+	if (!auth.ok) {
+		disableSmart(ctx, `model auth unavailable for ${modelName(model)}: ${auth.error}`)
+		return undefined
+	}
+
+	const maxTokens = Math.max(1, config.smartSearchMaxTokens)
+	const truncated = truncateForModel(input.resultText, model)
+	const sourceUrlText = input.sourceUrl ? `\n\nSource URL:\n${input.sourceUrl}` : ""
+	const prompt = `Smart query:\n${input.query}${sourceUrlText}\n\nResult text:\n${truncated.text}`
+	const options: SimpleStreamOptions = { maxTokens }
+	if (auth.apiKey !== undefined) options.apiKey = auth.apiKey
+	if (auth.headers !== undefined) options.headers = auth.headers
+	if (auth.env !== undefined) options.env = auth.env
+	if (signal !== undefined) options.signal = signal
+
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: smartSystemPrompt(config),
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }]
+		},
+		options
+	)
+
+	if (response.stopReason === "error" || response.stopReason === "aborted") {
+		throw new Error(response.errorMessage || response.stopReason)
+	}
+
+	const answer = extractText(response) || "Not found in provided results."
+	const truncationNotice = truncated.truncated
+		? `\n\nNote: Smart input was truncated to ${truncated.text.length}/${truncated.originalChars} characters to stay within half of ${modelName(model)} context. Answer may omit trimmed content.`
+		: ""
+	return {
+		text: `${answer}${truncationNotice}`,
+		details: {
+			query: input.query,
+			model: modelName(model),
+			inputChars: truncated.text.length,
+			originalInputChars: truncated.originalChars,
+			maxInputChars: truncated.maxChars,
+			truncated: truncated.truncated,
+			stopReason: response.stopReason,
+			usage: response.usage
+		}
+	}
+}

package/extensions/lovely-web/tools.ts

@@ -1,5 +1,6 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { Text } from "@earendil-works/pi-tui"
+import { StringEnum } from "@earendil-works/pi-ai"
+import type { AgentToolResult, ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { type Component, Text, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui"
 import { type TSchema, Type } from "typebox"
 import {
 	DEFAULT_PROVIDER_ID,
@@ -15,11 +16,12 @@ import {
 	type WebToolsConfig
 } from "./config.js"
 import { DEFAULT_TIMEOUT_MS } from "./constants.js"
+import { type FindMode, formatFindTextMatches } from "./find.js"
 import { asErrorMessage, formatSearchOutput, stringify } from "./format.js"
 import { DEFAULT_MAX_IMAGE_BYTES, imageImpl, MAX_IMAGE_BYTES } from "./image.js"
 import type { FetchOptions, SearchOptions } from "./providers/types.js"
 import { renderTextResult } from "./render.js"
-import type { ToolResult } from "./types.js"
+import { smartProcess } from "./smart.js"
 
 interface SearchToolArgs {
 	query: string
@@ -40,9 +42,30 @@ interface SearchToolArgs {
 interface FetchToolArgs extends FetchOptions {
 	url: string
 	includeMetadata?: boolean
+	smartQuery?: string
+	findText?: string[]
+	findMode?: FindMode
 }
 
-async function fetchSearchResultImage(config: WebToolsConfig, url: string, signal?: AbortSignal): Promise<ToolResult> {
+interface WebFetchRenderState {
+	smartCost?: string
+	smartCostInvalidated?: boolean
+}
+
+class WebFetchCallComponent implements Component {
+	constructor(
+		private readonly oneLine: string,
+		private readonly splitLines: string[]
+	) {}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		return visibleWidth(this.oneLine) <= width ? [this.oneLine] : this.splitLines.flatMap(line => wrapTextWithAnsi(line, width))
+	}
+}
+
+async function fetchSearchResultImage(config: WebToolsConfig, url: string, signal?: AbortSignal): Promise<AgentToolResult<unknown>> {
 	return imageImpl(
 		{
 			url,
@@ -87,13 +110,33 @@ function getSearchParameters(config: WebToolsConfig) {
 function getFetchParameters(config: WebToolsConfig) {
 	const configured = config.webFetchProvider
 	const providerId = configured && providers[configured]?.fetch ? configured : "firecrawl"
-	const params: Record<string, TSchema> = {
+	const params: Record<string, TSchema> & { smartQuery?: TSchema } = {
 		url: Type.String({ description: "The URL to fetch.", format: "uri" }),
 		timeout: Type.Optional(Type.Integer({ description: "Request timeout in milliseconds. Defaults to 30000.", minimum: 1 })),
 		includeMetadata: Type.Optional(
 			Type.Boolean({
 				description: "Append verbose page metadata to the markdown output. Defaults to false. Full metadata is always available in details."
 			})
+		),
+		findText: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Text strings to find in fetched markdown. Returns merged verification snippets."
+			})
+		),
+		findMode: Type.Optional(
+			StringEnum(["exact", "lower", "fuzzy"], {
+				description:
+					"Find mode. fuzzy matches normalized paragraph chunks (default); exact is case-sensitive literal; lower is case-insensitive literal."
+			})
+		)
+	}
+
+	if (config.smartSearchEnabled) {
+		params.smartQuery = Type.Optional(
+			Type.String({
+				description:
+					"Fast and intelligent model processes fetched markdown, produces grounded result. Questions, extraction, summarization, troubleshooting, or any other task you can do on a page. Give commanders intent (do what and why). Can be combined with findText; both run independently over the fetched text."
+			})
 		)
 	}
 
@@ -101,6 +144,28 @@ function getFetchParameters(config: WebToolsConfig) {
 	return Type.Object(params)
 }
 
+function formatUsd(amount: number): string {
+	if (amount === 0) return "$0"
+	if (amount < 0.0001) return "<$0.0001"
+	if (amount < 0.01) return `$${amount.toFixed(4)}`
+	return `$${amount.toFixed(3)}`
+}
+
+function smartCostLabel(details: unknown): string | undefined {
+	if (!details || typeof details !== "object") return undefined
+	const smart = (details as { smart?: unknown }).smart
+	if (!smart || typeof smart !== "object") return undefined
+	const usage = (smart as { usage?: unknown }).usage
+	if (!usage || typeof usage !== "object") return undefined
+	const cost = (usage as { cost?: unknown }).cost
+	if (cost && typeof cost === "object") {
+		const total = (cost as { total?: unknown }).total
+		if (typeof total === "number") return `cost:${formatUsd(total)}`
+	}
+	const totalTokens = (usage as { totalTokens?: unknown }).totalTokens
+	return typeof totalTokens === "number" ? `smart:${totalTokens} tok` : undefined
+}
+
 export function registerLovelyWebSearchTool(pi: ExtensionAPI, config: WebToolsConfig = lovelyWebConfigSpec.defaults) {
 	pi.registerTool({
 		name: "web_search",
@@ -128,7 +193,7 @@ export function registerLovelyWebSearchTool(pi: ExtensionAPI, config: WebToolsCo
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			try {
-				const config = loadConfig(ctx.cwd)
+				const config = loadConfig(ctx.cwd, ctx)
 				const searchProvider = getProvider("search", config)
 				const input = params as unknown as SearchToolArgs
 				onUpdate?.({
@@ -142,7 +207,7 @@ export function registerLovelyWebSearchTool(pi: ExtensionAPI, config: WebToolsCo
 				if (signal?.aborted) throw new Error("Search cancelled")
 
 				const first = searchResult.results[0]
-				let fetchedImage: ToolResult | undefined
+				let fetchedImage: AgentToolResult<unknown> | undefined
 				if (fetchResult === true && first?.url) {
 					onUpdate?.({ content: [{ type: "text", text: `Fetching first result: ${first.url}` }], details: undefined })
 					try {
@@ -163,18 +228,15 @@ export function registerLovelyWebSearchTool(pi: ExtensionAPI, config: WebToolsCo
 					}
 				}
 
-				const result: ToolResult = {
+				const details = fetchedImage ? { search: searchResult.raw, image: fetchedImage.details } : searchResult.raw
+				const result: AgentToolResult<unknown> = {
 					content: [{ type: "text", text: formatSearchOutput(searchResult.results) }, ...(fetchedImage?.content || [])],
-					details: fetchedImage ? { search: searchResult.raw, image: fetchedImage.details } : searchResult.raw
+					details
 				}
 				onUpdate?.(result)
 				return result
 			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web search failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
-				}
+				throw new Error(`Web search failed: ${asErrorMessage(error)}`)
 			}
 		}
 	})
@@ -187,13 +249,18 @@ export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsC
 		description: "Fetch a page as markdown. Metadata is verbose and opt-in.",
 		promptSnippet: "Use web_fetch to fetch a URL as markdown.",
 		promptGuidelines: [
-			"Use web_fetch when you need the full readable markdown content of a known URL.",
-			"Prefer web_fetch over bash/curl for web pages because web_fetch returns cleaned markdown suitable for agent context."
+			"Use web_fetch when you need the full readable markdown content of a known URL; prefer web_fetch over bash/curl for web pages because web_fetch returns cleaned markdown suitable for agent context.",
+			"Use web_fetch.findText for search inside the page. Snippets are returned.",
+			...(config.smartSearchEnabled
+				? [
+						"Use web_fetch.smartQuery for grounded page processing: summarization, extraction, comparison, troubleshooting, config/API details, or verbatim code/command examples. Any task that can be done on a page by a fast and intelligent LLM."
+					]
+				: [])
 		],
 		parameters: getFetchParameters(config),
 		renderCall(args, theme, context) {
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0)
 			const input = args as unknown as FetchToolArgs
+			const state = context.state as WebFetchRenderState
 			const bits: string[] = []
 			if (input.waitFor !== undefined) bits.push(`wait ${input.waitFor}ms`)
 			if (input.maxAgeHours !== undefined) bits.push(`max age ${input.maxAgeHours}h`)
@@ -201,23 +268,45 @@ export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsC
 			if (input.timeout !== undefined) bits.push(`timeout ${input.timeout}ms`)
 			if (input.includeMetadata) bits.push("metadata")
 			const suffix = bits.length ? ` ${theme.fg("dim", `(${bits.join(", ")})`)}` : ""
-			text.setText(`${theme.fg("toolTitle", theme.bold("web_fetch "))}${theme.fg("muted", input.url)}${suffix}`)
-			return text
+			const smart = input.smartQuery ? ` ${theme.fg("dim", `smart:"${input.smartQuery}"`)}` : ""
+			const find = input.findText?.length
+				? ` ${theme.fg("dim", `find:${input.findMode ?? "fuzzy"}:[${input.findText.map(text => `"${text}"`).join(", ")}]`)}`
+				: ""
+			const cost = state.smartCost ? ` ${theme.fg("dim", state.smartCost)}` : ""
+			const title = `${theme.fg("toolTitle", theme.bold("web_fetch "))}${theme.fg("muted", input.url)}`
+			const oneLine = `${title}${smart}${find}${suffix}${cost}`
+			const splitLines = [`${title}${suffix}${cost}`]
+			if (input.smartQuery) splitLines.push(theme.fg("dim", `smart:"${input.smartQuery}"`))
+			if (input.findText?.length) {
+				splitLines.push(theme.fg("dim", `find:${input.findMode ?? "fuzzy"}:[${input.findText.map(text => `"${text}"`).join(", ")}]`))
+			}
+			return new WebFetchCallComponent(oneLine, splitLines)
 		},
-		renderResult(result, { expanded, isPartial }, theme) {
+		renderResult(result, { expanded, isPartial }, theme, context) {
+			const state = context.state as WebFetchRenderState
+			const cost = !isPartial ? smartCostLabel(result.details) : undefined
+			if (cost && state.smartCost !== cost) {
+				state.smartCost = cost
+				if (!state.smartCostInvalidated) {
+					state.smartCostInvalidated = true
+					queueMicrotask(() => context.invalidate())
+				}
+			}
 			return renderTextResult(result, expanded, theme, isPartial ? "Fetching..." : "No content")
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const input = params as unknown as FetchToolArgs
+			let config: WebToolsConfig
+			let result: { markdown: string; metadata?: unknown; raw: unknown }
 			try {
-				const input = params as unknown as FetchToolArgs
-				const config = loadConfig(ctx.cwd)
+				config = loadConfig(ctx.cwd, ctx)
 				const fetchProvider = getProvider("fetch", config)
 				onUpdate?.({
 					content: [{ type: "text", text: `Fetching page with ${fetchProvider.label}: ${input.url}` }],
 					details: undefined
 				})
 
-				const result = await fetchProvider.fetch(
+				result = await fetchProvider.fetch(
 					resolveApiKey(fetchProvider, config),
 					input.url,
 					{
@@ -229,21 +318,56 @@ export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsC
 					signal
 				)
 				if (signal?.aborted) throw new Error("Fetch cancelled")
+			} catch (error) {
+				throw new Error(`Web fetch failed: ${asErrorMessage(error)}`)
+			}
 
-				const metadata = input.includeMetadata && result.metadata ? `\n\nMetadata:\n${stringify(result.metadata)}` : ""
-				const toolResult: ToolResult = {
-					content: [{ type: "text", text: `${result.markdown}${metadata}` }],
-					details: result.raw
+			const metadata = input.includeMetadata && result.metadata ? `\n\nMetadata:\n${stringify(result.metadata)}` : ""
+			const fetchedText = `${result.markdown}${metadata}`
+			const outputParts: string[] = []
+			const renderParts: string[] = []
+			const extraDetails: { smart?: unknown; findText?: unknown; renderText?: string } = {}
+			const findText = input.findText?.map(text => text.trim()).filter(Boolean) ?? []
+			if (input.smartQuery?.trim()) {
+				onUpdate?.({ content: [{ type: "text", text: "Processing fetched page with smart search" }], details: undefined })
+				let smartText: string
+				try {
+					const smart = await smartProcess(
+						config,
+						ctx,
+						{ query: input.smartQuery.trim(), resultText: fetchedText, sourceUrl: input.url },
+						signal
+					)
+					if (!smart) throw new Error("unavailable. Check /lovely-web smart search model and auth config.")
+					smartText = smart.text
+					extraDetails.smart = smart.details
+				} catch (error) {
+					if (signal?.aborted) throw error
+					smartText = `Smart search failed: ${asErrorMessage(error)}`
+					extraDetails.smart = { error: smartText }
+					if (findText.length === 0) throw new Error(smartText)
 				}
-				onUpdate?.(toolResult)
-				return toolResult
-			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web fetch failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
+				outputParts.push(smartText)
+				renderParts.push(smartText)
+			}
+			if (findText.length > 0) {
+				const found = formatFindTextMatches(fetchedText, findText, input.findMode ?? "fuzzy")
+				if (found.text) {
+					outputParts.push(found.text)
+					renderParts.push(found.renderText)
 				}
+				extraDetails.findText = found.details
 			}
+			const hasExtraOutput = outputParts.length > 0
+			const outputText = hasExtraOutput ? outputParts.join("\n\n---\n\n") : fetchedText
+			const renderText = renderParts.join("\n\n---\n\n")
+			if (hasExtraOutput && renderText !== outputText) extraDetails.renderText = renderText
+			const toolResult: AgentToolResult<unknown> = {
+				content: [{ type: "text", text: outputText }],
+				details: hasExtraOutput ? { fetch: result.raw, ...extraDetails } : result.raw
+			}
+			onUpdate?.(toolResult)
+			return toolResult
 		}
 	})
 
@@ -278,7 +402,7 @@ export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsC
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			try {
-				const config = loadConfig(ctx.cwd)
+				const config = loadConfig(ctx.cwd, ctx)
 				if (!isImageEnabled(config)) throw new Error("web_image is disabled. Enable it via /lovely-web.")
 				onUpdate?.({
 					content: [{ type: "text", text: `Fetching image: ${params.url}` }],
@@ -296,11 +420,7 @@ export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsC
 					onUpdate
 				)
 			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web image failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
-				}
+				throw new Error(`Web image failed: ${asErrorMessage(error)}`)
 			}
 		}
 	})

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xl0/pi-lovely-web",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"description": "Pi extension package for web_search, web_fetch, and web_image via Firecrawl, Exa, Tavily, and Brave.",
 	"keywords": [
 		"pi-package",
@@ -28,6 +28,7 @@
 		"check": "bun run typecheck && bun run biome:check",
 		"test": "bun run test/run.ts",
 		"test:image": "bun run test/image.ts",
+		"test:smart": "bun run test/smart-prompt.ts",
 		"test:update": "bun run test/update-references.ts",
 		"release": "bun publish --access public",
 		"lint": "biome lint .",
@@ -45,8 +46,9 @@
 		"typescript": "^6.0.3"
 	},
 	"dependencies": {
-		"@xl0/pi-lovely-config": "^0.1.0"
+		"@xl0/pi-lovely-config": "^0.1.1"
 	},
+
 	"peerDependencies": {
 		"@earendil-works/pi-ai": ">=0.79.10",
 		"@earendil-works/pi-coding-agent": ">=0.79.10",

package/extensions/lovely-web/types.ts

@@ -1,7 +0,0 @@
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai"
-
-export interface ToolResult {
-	content: Array<TextContent | ImageContent>
-	details: unknown
-	isError?: boolean
-}