@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.5

package/src/tools/irc.ts

@@ -386,20 +386,29 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 			};
 		}
 		const timeoutMs = this.#resolveTimeoutMs(params);
-		const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal);
-		if (!waited) {
-			const filterNote = from ? ` from ${from}` : "";
+		try {
+			const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal, {
+				liveness: { registry, senderId },
+			});
+			if (!waited) {
+				const filterNote = from ? ` from ${from}` : "";
+				return {
+					content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
+					details: { op: "wait", from: senderId, waited: null },
+					// A clean wait timeout carries no information once consumed.
+					useless: true,
+				};
+			}
 			return {
-				content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
-				details: { op: "wait", from: senderId, waited: null },
-				// A clean wait timeout carries no information once consumed.
-				useless: true,
+				content: [{ type: "text", text: formatIncoming(waited) }],
+				details: { op: "wait", from: senderId, waited },
 			};
+		} catch (error) {
+			if (signal?.aborted) {
+				throw error;
+			}
+			return errorResult(error instanceof Error ? error.message : String(error), { op: "wait", from: senderId });
 		}
-		return {
-			content: [{ type: "text", text: formatIncoming(waited) }],
-			details: { op: "wait", from: senderId, waited },
-		};
 	}
 
 	#executeInbox(registry: AgentRegistry, senderId: string, params: IrcParams): AgentToolResult<IrcDetails> {

package/src/tools/job.ts

@@ -61,9 +61,26 @@ interface CancelOutcome {
 	message: string;
 }
 
+/**
+ * A live subagent from the AgentRegistry that has no backing job in the
+ * AsyncJobManager — e.g. an idle agent woken (or a parked agent revived) via
+ * `irc`, or a spawn owned by another agent. Surfaced by `list` and empty-poll
+ * snapshots so the job tool's picture matches the UI's running-agent count.
+ */
+interface AgentActivitySnapshot {
+	id: string;
+	parentId?: string;
+	/** Latest activity gist recorded by the registry (display-only). */
+	activity?: string;
+	/** Time since the agent was registered. */
+	ageMs: number;
+}
+
 export interface JobToolDetails {
 	jobs: JobSnapshot[];
 	cancelled?: { id: string; status: CancelStatus }[];
+	/** Running subagents not represented by a job row in this result. */
+	agents?: AgentActivitySnapshot[];
 }
 
 /**
@@ -118,7 +135,9 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			if (params.cancel?.length || params.poll?.length) {
 				throw new ToolError("`list` cannot be combined with `poll` or `cancel`.");
 			}
-			return this.#buildResult(manager, manager.getAllJobs(ownerFilter), []);
+			const jobs = manager.getAllJobs(ownerFilter);
+			const agents = this.#runningAgentsOutsideJobs();
+			return this.#buildResult(manager, jobs, [], agents);
 		}
 
 		const cancelIds = params.cancel ?? [];
@@ -166,15 +185,37 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 				const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
 				return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
 			}
-			const message = requestedPollIds?.length
-				? `No matching jobs found for IDs: ${requestedPollIds.join(", ")}`
-				: "No running background jobs to wait for.";
+			// Zero pollable jobs is not necessarily "nothing running": agents
+			// woken via irc or owned by another agent run with no job entry.
+			// Report them so the snapshot matches the UI's running-agent count
+			// (task job ids are agent ids, so a stale poll id often names one).
+			const agents = this.#runningAgentsOutsideJobs();
+			const lines: string[] = [];
+			if (requestedPollIds?.length) {
+				lines.push(`No matching jobs found for IDs: ${requestedPollIds.join(", ")}`);
+				const registry = this.session.agentRegistry;
+				for (const id of requestedPollIds) {
+					const ref = registry?.get(id);
+					if (!ref) continue;
+					lines.push(
+						ref.status === "running"
+							? `- \`${id}\` is a running agent with no job entry — coordinate via \`irc\`; transcript at history://${id}`
+							: `- \`${id}\` is a ${ref.status} agent (its job is gone) — transcript at history://${id}`,
+					);
+				}
+			} else {
+				lines.push("No running background jobs to wait for.");
+			}
+			if (agents.length > 0) {
+				lines.push("", ...this.#describeAgents(agents));
+			}
 			return {
-				content: [{ type: "text", text: message }],
-				details: { jobs: [] },
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: { jobs: [], ...(agents.length ? { agents } : {}) },
 				// Nothing found / nothing to wait for is noise once consumed —
-				// the follow-up call has already corrected course.
-				useless: true,
+				// the follow-up call has already corrected course. Running agents
+				// are real state the model may act on, so keep those results.
+				...(agents.length === 0 ? { useless: true } : {}),
 			};
 		}
 
@@ -266,6 +307,57 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		return out;
 	}
 
+	/**
+	 * Running subagents from the registry that are not covered by one of the
+	 * caller's running jobs. Agents woken via `irc` (idle wake / park revival)
+	 * and spawns owned by another agent run with no AsyncJobManager entry, yet
+	 * the UI's agent badge counts them — a snapshot must account for that
+	 * activity instead of implying the system is quiet. Existence is already
+	 * public via the `irc` roster, so listing ids here leaks nothing new; job
+	 * *control* stays owner-scoped.
+	 */
+	#runningAgentsOutsideJobs(): AgentActivitySnapshot[] {
+		const registry = this.session.agentRegistry;
+		if (!registry) return [];
+		const selfId = this.session.getAgentId?.() ?? undefined;
+		// Cover = the caller's RUNNING jobs only. A settled job still sitting in
+		// delivery retention must not hide its agent if that agent was re-woken
+		// (e.g. via irc) and is running again without a job.
+		const covered = new Set<string>();
+		const manager = this.session.asyncJobManager;
+		if (manager) {
+			for (const job of manager.getRunningJobs(selfId ? { ownerId: selfId } : undefined)) {
+				covered.add(job.id);
+				if (job.agentId) covered.add(job.agentId);
+			}
+		}
+		const now = Date.now();
+		const out: AgentActivitySnapshot[] = [];
+		for (const ref of registry.list()) {
+			if (ref.kind !== "sub" || ref.status !== "running") continue;
+			if (ref.id === selfId || covered.has(ref.id)) continue;
+			out.push({
+				id: ref.id,
+				...(ref.parentId ? { parentId: ref.parentId } : {}),
+				...(ref.activity ? { activity: ref.activity } : {}),
+				ageMs: Math.max(0, now - ref.createdAt),
+			});
+		}
+		return out;
+	}
+
+	/** Model-facing lines for the running-agents section shared by `list` and empty-poll results. */
+	#describeAgents(agents: AgentActivitySnapshot[]): string[] {
+		const lines = [`## Running Agents (${agents.length}) — not job-backed\n`];
+		for (const agent of agents) {
+			const parent = agent.parentId ? ` (spawned by \`${agent.parentId}\`)` : "";
+			const activity = agent.activity ? ` — ${agent.activity}` : "";
+			lines.push(`- \`${agent.id}\`${parent} — up ${formatDuration(agent.ageMs)}${activity}`);
+		}
+		lines.push("", "These agents have no job entry; coordinate via `irc`, transcripts at `history://<id>`.");
+		return lines;
+	}
+
 	#snapshotJobs(
 		jobs: {
 			id: string;
@@ -305,6 +397,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			errorText?: string;
 		}[],
 		cancelOutcomes: CancelOutcome[],
+		agents: AgentActivitySnapshot[] = [],
 	): AgentToolResult<JobToolDetails> {
 		// Deduplicate by id (cancelled jobs may also appear in the watched set).
 		const seen = new Set<string>();
@@ -350,9 +443,21 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			}
 		}
 
+		if (agents.length > 0) {
+			if (lines.length > 0) lines.push("");
+			lines.push(...this.#describeAgents(agents));
+		}
+
+		// A tool result must never be empty text — the model cannot tell "no
+		// jobs" from a malfunction (reported exactly that way in QA).
+		if (lines.length === 0) {
+			lines.push("No background jobs.");
+		}
+
 		const details: JobToolDetails = {
 			jobs: jobResults,
 			...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
+			...(agents.length ? { agents } : {}),
 		};
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
@@ -463,8 +568,9 @@ export const jobToolRenderer = {
 		args?: JobRenderArgs,
 	): Component {
 		let jobs = result.details?.jobs ?? [];
+		const agents = result.details?.agents ?? [];
 
-		if (jobs.length === 0) {
+		if (jobs.length === 0 && agents.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text || "No jobs to process";
 			const header = renderStatusLine({ icon: "warning", title: describeTarget(args) || "Job" }, uiTheme);
 			return new Text([header, formatEmptyMessage(fallback, uiTheme)].join("\n"), 0, 0);
@@ -474,7 +580,10 @@ export const jobToolRenderer = {
 			? !args.list && (!args.cancel || args.cancel.length === 0 || args.poll !== undefined)
 			: true;
 
-		if (!options.isPartial && isPollCall) {
+		// Agent-carrying results (list / empty-poll roster) are real snapshots,
+		// not displaceable waiting frames — only agentless polls collapse their
+		// still-running rows once sealed.
+		if (!options.isPartial && isPollCall && agents.length === 0) {
 			jobs = jobs.filter(job => job.status !== "running");
 			if (jobs.length === 0) {
 				return new Text("", 0, 0);
@@ -490,20 +599,26 @@ export const jobToolRenderer = {
 		if (counts.completed > 0) meta.push(uiTheme.fg("success", `${counts.completed} done`));
 		if (counts.failed > 0) meta.push(uiTheme.fg("error", `${counts.failed} failed`));
 		if (counts.cancelled > 0) meta.push(uiTheme.fg("warning", `${counts.cancelled} cancelled`));
+		if (agents.length > 0 && jobs.length > 0) {
+			meta.push(uiTheme.fg("accent", `${agents.length} agent${agents.length === 1 ? "" : "s"}`));
+		}
 
-		const headerIcon: ToolUIStatus = counts.failed > 0 ? "warning" : counts.running > 0 ? "info" : "success";
+		const headerIcon: ToolUIStatus =
+			counts.failed > 0 ? "warning" : counts.running > 0 || agents.length > 0 ? "info" : "success";
 		const jobsNoun = jobs.length === 1 ? "job" : "jobs";
 		const description =
-			counts.running > 0
-				? counts.running === jobs.length
-					? `waiting on ${jobs.length} ${jobsNoun}`
-					: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
-				: `${jobs.length} ${jobsNoun} settled`;
+			jobs.length === 0
+				? `${agents.length} running agent${agents.length === 1 ? "" : "s"} — no jobs`
+				: counts.running > 0
+					? counts.running === jobs.length
+						? `waiting on ${jobs.length} ${jobsNoun}`
+						: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
+					: `${jobs.length} ${jobsNoun} settled`;
 
 		const header = renderStatusLine(
 			{
 				icon: headerIcon,
-				spinnerFrame: counts.running > 0 ? options.spinnerFrame : undefined,
+				spinnerFrame: counts.running > 0 || agents.length > 0 ? options.spinnerFrame : undefined,
 				title: description,
 				meta,
 			},
@@ -598,7 +713,32 @@ export const jobToolRenderer = {
 					uiTheme,
 				);
 
-				const all = [header, ...itemLines].map(l => truncateToWidth(l, width, Ellipsis.Unicode));
+				// Agents run outside job control; render them as their own tree so
+				// they never skew the job counts or the "waiting on N jobs" title.
+				const agentLines =
+					agents.length === 0
+						? []
+						: renderTreeList<AgentActivitySnapshot>(
+								{
+									items: agents,
+									expanded,
+									maxCollapsed: COLLAPSED_LIST_LIMIT,
+									itemType: "agent",
+									renderItem: agent => {
+										const icon = formatStatusIcon("running", uiTheme, options.spinnerFrame);
+										const badge = formatBadge("agent", "accent", uiTheme);
+										const gist = agent.activity
+											? ` ${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(agent.activity), LABEL_MAX_WIDTH, Ellipsis.Unicode))}`
+											: "";
+										const parent = agent.parentId ? uiTheme.fg("dim", ` ← ${agent.parentId}`) : "";
+										const age = uiTheme.fg("dim", formatDuration(agent.ageMs));
+										return [`${icon} ${uiTheme.fg("muted", agent.id)} ${badge}${gist} ${age}${parent}`];
+									},
+								},
+								uiTheme,
+							);
+
+				const all = [header, ...itemLines, ...agentLines].map(l => truncateToWidth(l, width, Ellipsis.Unicode));
 				cached = { key, lines: all };
 				return all;
 			},

package/src/tools/write.ts

@@ -82,6 +82,30 @@ import { toolResult } from "./tool-result";
 const LOOSE_HASHLINE_HEADER_RE = /^\s*\[[^#\r\n]+#[^ \t\r\n]*\]\s*$/;
 const EXECUTABLE_NOTICE = "[Notice: Made executable via chmod +x]";
 
+const BULK_DIRECTIVE_RE = /^#?(\d+)\s*[:=]\s*(@ours|@theirs|@base|@both)$/;
+
+/**
+ * Parse `conflict://*` per-id directive content: every non-empty line must be
+ * `<id>: @side` (also accepted: `#<id> = @side`). Returns `null` when the
+ * content is not directive-shaped (→ uniform bulk mode); throws on duplicate
+ * ids so a typo never silently drops a resolution.
+ */
+function parseBulkDirectives(content: string): Map<number, string> | null {
+	const map = new Map<number, string>();
+	for (const raw of content.split("\n")) {
+		const line = raw.trim();
+		if (line.length === 0) continue;
+		const match = line.match(BULK_DIRECTIVE_RE);
+		if (!match) return null;
+		const id = Number.parseInt(match[1], 10);
+		if (map.has(id)) {
+			throw new ToolError(`Bulk directive lists conflict #${id} twice — each id may appear once.`);
+		}
+		map.set(id, match[2]);
+	}
+	return map.size > 0 ? map : null;
+}
+
 const writeSchema = type({
 	path: type("string").describe("file path"),
 	content: type("string").describe("file content"),
@@ -591,7 +615,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 		const expanded = expandContentTokens(replacementContent, entry);
 		const originalText = await Bun.file(absolutePath).text();
-		const newContent = spliceConflict(originalText, entry, expanded);
+		const splice = spliceConflict(originalText, entry, expanded);
+		const newContent = splice.text;
 
 		await writethroughNoop(absolutePath, newContent, signal);
 		invalidateFsScanAfterWrite(absolutePath);
@@ -626,6 +651,10 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		if (stripped) {
 			resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
 		}
+		const echoTrimmed = splice.trimmedLeading + splice.trimmedTrailing;
+		if (echoTrimmed > 0) {
+			resultText += `\nNote: dropped ${echoTrimmed} content line(s) that duplicated the code adjacent to the conflict region — writes replace only the marker block; surrounding lines stay in place.`;
+		}
 
 		return {
 			content: [{ type: "text", text: resultText }],
@@ -671,6 +700,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		replacementContent: string,
 		stripped: boolean,
 		signal: AbortSignal | undefined,
+		rawContent: string = replacementContent,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		const history = getConflictHistory(this.session);
 		const allEntries = history.entries();
@@ -680,8 +710,28 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			);
 		}
 
+		// Per-id directive mode: content made solely of `<id>: @side` lines
+		// resolves each listed conflict with that side in one call. Ideal for
+		// merge-hell files where dozens of pick-one blocks each need their own
+		// winner — one call instead of one write per conflict. Parsed from the
+		// PRE-strip content: hashline prefix stripping would otherwise eat the
+		// `<id>: ` heads as echoed line numbers.
+		const directives = parseBulkDirectives(rawContent) ?? parseBulkDirectives(replacementContent);
+		if (directives) {
+			const known = new Set(allEntries.map(entry => entry.id));
+			const unknown = [...directives.keys()].filter(id => !known.has(id));
+			if (unknown.length > 0) {
+				throw new ToolError(
+					`Bulk directive references unknown conflict id(s) ${unknown.map(id => `#${id}`).join(", ")}. Currently registered: ${allEntries.map(e => `#${e.id}`).join(", ")}.`,
+				);
+			}
+		}
+		const selectedEntries = directives ? allEntries.filter(entry => directives.has(entry.id)) : allEntries;
+		const contentFor = (entry: ConflictEntry): string =>
+			directives ? (directives.get(entry.id) as string) : replacementContent;
+
 		const byFile = new Map<string, ConflictEntry[]>();
-		for (const entry of allEntries) {
+		for (const entry of selectedEntries) {
 			const bucket = byFile.get(entry.absolutePath) ?? [];
 			bucket.push(entry);
 			byFile.set(entry.absolutePath, bucket);
@@ -690,6 +740,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		const succeededFiles: { displayPath: string; count: number; header?: string }[] = [];
 		const failedFiles: { displayPath: string; count: number; error: string }[] = [];
 		let totalResolvedIds = 0;
+		let totalEchoTrimmed = 0;
 
 		for (const [absolutePath, fileEntries] of byFile) {
 			const sample = fileEntries[0]!;
@@ -720,8 +771,10 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			}
 			for (const entry of fileEntries) {
 				try {
-					const expanded = expandContentTokens(replacementContent, entry);
-					text = spliceConflict(text, entry, expanded);
+					const expanded = expandContentTokens(contentFor(entry), entry);
+					const splice = spliceConflict(text, entry, expanded);
+					text = splice.text;
+					totalEchoTrimmed += splice.trimmedLeading + splice.trimmedTrailing;
 					resolvedEntries.push(entry);
 				} catch (error) {
 					// A locate-miss for a region an earlier entry already spliced
@@ -766,6 +819,17 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				summaryLines.push(`  ${file.displayPath}: ${file.count} ${conflictWord(file.count)}`);
 			}
 		}
+		if (directives && selectedEntries.length < allEntries.length) {
+			const remaining = allEntries.filter(entry => !directives.has(entry.id)).map(entry => `#${entry.id}`);
+			summaryLines.push(
+				`Directive mode: ${remaining.length} unlisted ${conflictWord(remaining.length)} still registered (${remaining.join(", ")}).`,
+			);
+		}
+		if (totalEchoTrimmed > 0) {
+			summaryLines.push(
+				`Note: dropped ${totalEchoTrimmed} content line(s) that duplicated code adjacent to conflict regions — writes replace only the marker block; surrounding lines stay in place.`,
+			);
+		}
 		if (failedFiles.length > 0) {
 			summaryLines.push(
 				`Failed to resolve ${failedFiles.length} ${fileWord(failedFiles.length)} — registered entries left intact for retry:`,
@@ -781,7 +845,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			summaryLines.push("Snapshots:");
 			for (const header of headerLines) summaryLines.push(`  ${header}`);
 		}
-		if (stripped) {
+		if (stripped && !directives) {
 			summaryLines.push("Note: auto-stripped hashline display prefixes from content before writing.");
 		}
 		const resultText = summaryLines.join("\n");
@@ -849,7 +913,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				emitWriteProgress(onUpdate, cleanContent, path);
 				const result =
 					conflictUri.id === "*"
-						? await this.#resolveAllConflicts(cleanContent, stripped, signal)
+						? await this.#resolveAllConflicts(cleanContent, stripped, signal, content)
 						: await this.#resolveSingleConflictById(conflictUri.id, cleanContent, stripped, signal);
 				if (conflictUri.recoveredPrefix !== undefined) {
 					appendNoteToResult(

package/src/vibe/runtime.ts

@@ -603,7 +603,7 @@ export class VibeSessionRegistry {
 					);
 				}
 			},
-			{ id: `${record.id}-t${turnIndex}`, ownerId: record.ownerId },
+			{ id: `${record.id}-t${turnIndex}`, agentId: record.id, ownerId: record.ownerId },
 		);
 		turn.jobId = jobId;
 		record.turn = turn;

package/src/web/search/providers/browser-headers.ts

@@ -1,22 +1,35 @@
 import { HeaderGenerator } from "header-generator";
 
-// Instantiate the singleton header generator.
-// This matches modern browsers from real-world query statistics
-// and randomizes between Chrome, Firefox, Safari, and Edge.
-const generator = new HeaderGenerator({
-	browserListQuery: "last 3 versions",
-	devices: ["desktop"],
-	operatingSystems: ["windows", "macos", "linux"],
-	locales: ["en-US", "en"],
-	httpVersion: "2",
-	strict: false,
-});
+// Lazily instantiate the singleton header generator. Bun single-file binaries do not
+// bundle header-generator's fs-loaded data_files, so construction may throw when the
+// original build-time node_modules path is absent.
+let generator: HeaderGenerator | undefined;
+let generatorUnavailable = false;
+
+function getHeaderGenerator(): HeaderGenerator | undefined {
+	if (generatorUnavailable) return undefined;
+	try {
+		generator ??= new HeaderGenerator({
+			browserListQuery: "last 3 versions",
+			devices: ["desktop"],
+			operatingSystems: ["windows", "macos", "linux"],
+			locales: ["en-US", "en"],
+			httpVersion: "2",
+			strict: false,
+		});
+		return generator;
+	} catch {
+		generatorUnavailable = true;
+		return undefined;
+	}
+}
 
 // A fallback desktop Mac Chrome navigation fingerprint matching
 // the previous static default setup for deterministic or non-randomized calls.
 const CHROME_FALLBACK_HEADERS: Record<string, string> = {
 	Accept:
 		"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+	"Accept-Encoding": "gzip, deflate, br, zstd",
 	"Accept-Language": "en-US,en;q=0.9",
 	"Cache-Control": "max-age=0",
 	Priority: "u=0, i",
@@ -81,10 +94,14 @@ export function buildBrowserNavigationHeaders(options?: { randomized?: boolean }
 		return { ...CHROME_FALLBACK_HEADERS };
 	}
 
+	const generator = getHeaderGenerator();
+	if (!generator) {
+		return { ...CHROME_FALLBACK_HEADERS };
+	}
+
 	try {
 		// Generate realistic, consistent headers with the Bayesian generator
-		const generated = generator.getHeaders();
-		return canonicalizeHeaderNames(generated);
+		return canonicalizeHeaderNames(generator.getHeaders());
 	} catch {
 		// Gracefully recover to the robust default profile on unexpected generator errors
 		return { ...CHROME_FALLBACK_HEADERS };

package/dist/types/modes/components/model-selector.d.ts

@@ -1,37 +0,0 @@
-import type { Model } from "@oh-my-pi/pi-ai";
-import { Container, Input, type SgrMouseEvent, type TUI } from "@oh-my-pi/pi-tui";
-import type { ModelRegistry } from "../../config/model-registry.js";
-import type { Settings } from "../../config/settings.js";
-import { type ConfiguredThinkingLevel } from "../../thinking.js";
-interface ScopedModelItem {
-    model: Model;
-    thinkingLevel?: string;
-}
-type ModelSelectorAction = "modelRole" | "retryFallback";
-type RoleSelectCallback = (model: Model, role: string | null, thinkingLevel?: ConfiguredThinkingLevel, selector?: string, action?: ModelSelectorAction) => void;
-/**
- * Component that renders a model selector with provider tabs and context menu.
- * - Tab/Arrow Left/Right: Switch between provider tabs
- * - Arrow Up/Down: Navigate model list
- * - Enter: Open context menu to select action
- * - Escape: Close menu or selector
- */
-export declare class ModelSelectorComponent extends Container {
-    #private;
-    constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
-        temporaryOnly?: boolean;
-        directSelect?: boolean;
-        pickerHint?: string;
-        initialSearchInput?: string;
-        currentContextTokens?: number;
-    });
-    /**
-     * Concatenate children like Container.render, recording where the model list
-     * lands so routed mouse events can be hit-tested against it.
-     */
-    render(width: number): readonly string[];
-    routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
-    handleInput(keyData: string): void;
-    getSearchInput(): Input;
-}
-export {};

package/dist/types/tools/bash-command-fixup.d.ts

@@ -1,3 +0,0 @@
-/** Compatibility shim for extensions importing the historical bash fixup helper. */
-export type { BashFixupResult } from "@oh-my-pi/pi-natives";
-export { applyBashFixups } from "@oh-my-pi/pi-natives";