@oh-my-pi/pi-coding-agent 15.2.3 → 15.3.0

package/src/task/types.ts

@@ -173,6 +173,7 @@ export interface AgentDefinition {
 	thinkingLevel?: ThinkingLevel;
 	output?: unknown;
 	blocking?: boolean;
+	autoloadSkills?: string[];
 	source: AgentSource;
 	filePath?: string;
 }
@@ -211,6 +212,30 @@ export interface AgentProgress {
 	modelOverride?: string | string[];
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
+	/**
+	 * Auto-retry state when the subagent is sleeping between provider retries
+	 * (e.g. 429 rate-limit with retry-after). Cleared when the retry resolves
+	 * or fails. Surfacing this to the parent prevents the task tool from
+	 * looking indefinitely "in progress" when a child is actually blocked on
+	 * provider quota.
+	 */
+	retryState?: {
+		attempt: number;
+		maxAttempts: number;
+		delayMs: number;
+		errorMessage: string;
+		startedAtMs: number;
+	};
+	/**
+	 * Terminal retry failure surfaced once the subagent gave up retrying
+	 * (e.g. retry-after exceeded the cap, or all attempts exhausted). Carries
+	 * the final error so the parent UI can render "blocked: rate-limited"
+	 * instead of waiting for a status that never arrives.
+	 */
+	retryFailure?: {
+		attempt: number;
+		errorMessage: string;
+	};
 }
 
 /** Result from a single agent execution */
@@ -250,6 +275,16 @@ export interface SingleResult {
 	nestedPatches?: NestedRepoPatch[];
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
+	/**
+	 * Terminal retry failure, when the subagent exited because the auto-retry
+	 * loop gave up (retry-after exceeded the cap, or all attempts exhausted).
+	 * Lets the parent task tool surface a "blocked: rate-limited" outcome
+	 * instead of a generic failure.
+	 */
+	retryFailure?: {
+		attempt: number;
+		errorMessage: string;
+	};
 	/** Output metadata for agent:// URL integration */
 	outputMeta?: { lineCount: number; charCount: number };
 }

package/src/tools/bash-command-fixup.ts

@@ -35,13 +35,3 @@ export interface BashFixupResult {
 export function applyBashFixups(command: string): BashFixupResult {
 	return nativeApplyBashFixups(command);
 }
-
-/**
- * Human-readable notice for the fixups that fired. Mirrors the shape of
- * `formatTimeoutClampNotice` so it can ride alongside the other bash notices.
- */
-export function formatBashFixupNotice(stripped: readonly string[]): string | undefined {
-	if (!stripped.length) return undefined;
-	const quoted = stripped.map(s => `\`${s}\``).join(", ");
-	return `<system-warning>Stripped redundant ${quoted} — bash output is already truncated and stderr is already merged into stdout. NEVER use these patterns.</system-warning>`;
-}

package/src/tools/bash.ts

@@ -17,7 +17,7 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
-import { applyBashFixups, formatBashFixupNotice } from "./bash-command-fixup";
+import { applyBashFixups } from "./bash-command-fixup";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
@@ -233,7 +233,6 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly #asyncEnabled: boolean;
 	readonly #autoBackgroundEnabled: boolean;
 	readonly #autoBackgroundThresholdMs: number;
-	#bashFixupNoticeEmitted = false;
 
 	constructor(private readonly session: ToolSession) {
 		this.#asyncEnabled = this.session.settings.get("async.enabled");
@@ -475,12 +474,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		// Apply conservative bash fixups (strip trailing `| head|tail` and redundant
 		// `2>&1`). The helper is single-line only and refuses anything that could
 		// change semantics.
-		let bashFixups: string[] = [];
 		if (this.session.settings.get("bash.stripTrailingHeadTail")) {
 			const fixup = applyBashFixups(command);
 			if (fixup.stripped.length > 0) {
 				command = fixup.command;
-				bashFixups = fixup.stripped;
 			}
 		}
 
@@ -562,11 +559,6 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const pendingNotices: string[] = [];
 		const timeoutClampNotice = formatTimeoutClampNotice(requestedTimeoutSec, timeoutSec);
 		if (timeoutClampNotice) pendingNotices.push(timeoutClampNotice);
-		const bashFixupNotice = this.#bashFixupNoticeEmitted ? undefined : formatBashFixupNotice(bashFixups);
-		if (bashFixupNotice) {
-			pendingNotices.push(bashFixupNotice);
-			this.#bashFixupNoticeEmitted = true;
-		}
 
 		if (asyncRequested) {
 			if (!AsyncJobManager.instance()) {

package/src/utils/clipboard.ts

@@ -2,7 +2,13 @@ import { execSync } from "node:child_process";
 import type { ClipboardImage } from "@oh-my-pi/pi-natives";
 import * as native from "@oh-my-pi/pi-natives";
 
-const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+function hasDisplay(): boolean {
+	return process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+
+function isWsl(): boolean {
+	return process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
 
 /**
  * Copy text to the system clipboard.
@@ -59,11 +65,66 @@ export async function copyToClipboard(text: string): Promise<void> {
 	}
 }
 
+// PowerShell one-liner that emits the clipboard image as base64-encoded PNG on
+// stdout, or nothing when the clipboard does not hold image data. Used as the
+// WSL bridge — arboard cannot read the Windows clipboard through WSLg.
+const POWERSHELL_IMAGE_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$img = [System.Windows.Forms.Clipboard]::GetImage()
+if ($img -ne $null) {
+	$ms = New-Object System.IO.MemoryStream
+	$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+	[Console]::Out.Write([Convert]::ToBase64String($ms.ToArray()))
+}
+`;
+
+const POWERSHELL_TIMEOUT_MS = 5000;
+
+/**
+ * Read a clipboard image through the Windows host's PowerShell.
+ *
+ * WSLg exposes a Wayland socket but no native clipboard image transport, so
+ * `arboard` returns `ContentNotAvailable`. PowerShell, reached via WSL interop,
+ * can read the Windows clipboard directly and round-trip the bitmap as PNG.
+ *
+ * Returns null when no image is on the clipboard, the host PowerShell is
+ * missing, or the bridge times out.
+ */
+async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
+	try {
+		const proc = Bun.spawn(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_IMAGE_SCRIPT], {
+			stdout: "pipe",
+			stderr: "ignore",
+			stdin: "ignore",
+		});
+		const timer = setTimeout(() => proc.kill(), POWERSHELL_TIMEOUT_MS);
+		let stdout = "";
+		try {
+			stdout = await new Response(proc.stdout).text();
+			await proc.exited;
+		} finally {
+			clearTimeout(timer);
+		}
+		if (proc.exitCode !== 0) return null;
+		const b64 = stdout.trim();
+		if (!b64) return null;
+		const bytes = Buffer.from(b64, "base64");
+		if (bytes.byteLength === 0) return null;
+		return { data: new Uint8Array(bytes), mimeType: "image/png" };
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Read an image from the system clipboard.
  *
  * Returns null on Termux (no image clipboard support) or when no display
- * server is available (headless/SSH without forwarding).
+ * server is available (headless/SSH without forwarding). Under WSL the
+ * Windows clipboard is reached through `powershell.exe`, since WSLg's
+ * Wayland clipboard does not carry image payloads through to `arboard`.
  *
  * @returns PNG payload or null when no image is available.
  */
@@ -72,7 +133,11 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 		return null;
 	}
 
-	if (!hasDisplay) {
+	if (isWsl()) {
+		const image = await readImageViaPowerShell();
+		if (image) return image;
+		// Fall through: arboard may still succeed on a future WSLg release.
+	} else if (!hasDisplay()) {
 		return null;
 	}
 

package/src/utils/commit-message-generator.ts

@@ -15,6 +15,8 @@ import { toReasoningEffort } from "../thinking";
 
 const COMMIT_SYSTEM_PROMPT = prompt.render(commitSystemPrompt);
 const MAX_DIFF_CHARS = 4000;
+const COMMIT_MAX_TOKENS = 60;
+const REASONING_SAFE_MAX_TOKENS = 1024;
 
 /** File patterns that should be excluded from commit message generation diffs. */
 const NOISE_SUFFIXES = [".lock", ".lockb", "-lock.json", "-lock.yaml"];
@@ -99,13 +101,16 @@ export async function generateCommitMessage(
 		if (!apiKey) continue;
 
 		try {
+			const maxTokens = candidate.model.reasoning
+				? Math.max(COMMIT_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+				: COMMIT_MAX_TOKENS;
 			const response = await completeSimple(
 				candidate.model,
 				{
 					systemPrompt: [COMMIT_SYSTEM_PROMPT],
 					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
 				},
-				{ apiKey, maxTokens: 60, reasoning: toReasoningEffort(candidate.thinkingLevel) },
+				{ apiKey, maxTokens, reasoning: toReasoningEffort(candidate.thinkingLevel) },
 			);
 
 			if (response.stopReason === "error") {

package/src/utils/image-resize.ts

@@ -5,6 +5,7 @@ export interface ImageResizeOptions {
 	maxHeight?: number;
 	maxBytes?: number;
 	jpegQuality?: number;
+	excludeWebP?: boolean;
 }
 
 export interface ResizedImage {
@@ -29,6 +30,7 @@ const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
 	maxHeight: 1568,
 	maxBytes: DEFAULT_MAX_BYTES,
 	jpegQuality: 80,
+	excludeWebP: Bun.env.OMP_NO_WEBP !== undefined,
 };
 
 /** Pick the smallest of N encoded buffers. */
@@ -49,11 +51,13 @@ Buffer.prototype.toBase64 = function (this: Buffer) {
  *
  * Strategy:
  *  1. Probe metadata. If already within all limits, return original.
- *  2. Resize to fit max dimensions and encode at high quality across PNG/JPEG/WebP — return smallest.
+ *  2. Resize to fit max dimensions and encode at high quality across PNG/JPEG (+ WebP) — return smallest.
  *  3. If still too large, walk a lossy JPEG/WebP quality ladder.
  *  4. If still too large, walk a dimension-scale ladder × quality ladder.
  *  5. If still too large, return the smallest variant produced.
  *
+ * Set OMP_NO_WEBP to exclude WebP from encoding (llama.cpp STB doesn't decode it).
+ *
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
@@ -99,44 +103,65 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			targetHeight = opts.maxHeight;
 		}
 
-		// First-attempt encoder: try PNG, JPEG, and lossy WebP — return whichever is smallest.
-		// PNG wins for line art / few-color UI; JPEG and WebP win for photographic content;
-		// WebP usually beats JPEG by 25–35% at the same perceptual quality.
+		// First-attempt encoder: try PNG and JPEG (+ WebP if not excluded) — return smallest.
+		// PNG wins for line art / few-color UI; JPEG wins for photographic content;
+		// WebP usually beats JPEG by 25–35% but is disabled when OMP_NO_WEBP is set
+		// because many local inference backends (llama.cpp STB) don't decode it.
 		async function encodeSmallest(
 			width: number,
 			height: number,
 			quality: number,
 		): Promise<{ buffer: Uint8Array; mimeType: string }> {
-			const [pngBuffer, jpegBuffer, webpBuffer] = await Promise.all([
-				new Bun.Image(inputBuffer).resize(width, height).png().bytes(),
-				new Bun.Image(inputBuffer).resize(width, height).jpeg({ quality }).bytes(),
-				new Bun.Image(inputBuffer).resize(width, height).webp({ quality }).bytes(),
+			const candidates = await Promise.all([
+				new Bun.Image(inputBuffer)
+					.resize(width, height)
+					.png()
+					.bytes()
+					.then(b => ({ buffer: b, mimeType: "image/png" })),
+				new Bun.Image(inputBuffer)
+					.resize(width, height)
+					.jpeg({ quality })
+					.bytes()
+					.then(b => ({ buffer: b, mimeType: "image/jpeg" })),
+				...(opts.excludeWebP
+					? []
+					: [
+							new Bun.Image(inputBuffer)
+								.resize(width, height)
+								.webp({ quality })
+								.bytes()
+								.then(b => ({ buffer: b, mimeType: "image/webp" })),
+						]),
 			]);
-			return pickSmallest(
-				{ buffer: pngBuffer, mimeType: "image/png" },
-				{ buffer: jpegBuffer, mimeType: "image/jpeg" },
-				{ buffer: webpBuffer, mimeType: "image/webp" },
-			);
+			return pickSmallest(...candidates);
 		}
 
-		// Lossy-only encoder — used in quality/dimension fallback ladders where PNG can't shrink
-		// further (PNG quality is a no-op). Picks the smaller of JPEG vs lossy WebP at the
-		// requested quality.
+		// Lossy encoder for quality/dimension fallback ladders. PNG is excluded since
+		// it's lossless and doesn't respond to quality parameters. WebP is included
+		// unless OMP_NO_WEBP is set (llama.cpp STB incompatibility).
 		async function encodeLossy(
 			width: number,
 			height: number,
 			quality: number,
 		): Promise<{ buffer: Uint8Array; mimeType: string }> {
-			const [jpegBuffer, webpBuffer] = await Promise.all([
-				new Bun.Image(inputBuffer).resize(width, height).jpeg({ quality }).bytes(),
-				new Bun.Image(inputBuffer).resize(width, height).webp({ quality }).bytes(),
+			const candidates = await Promise.all([
+				new Bun.Image(inputBuffer)
+					.resize(width, height)
+					.jpeg({ quality })
+					.bytes()
+					.then(b => ({ buffer: b, mimeType: "image/jpeg" })),
+				...(opts.excludeWebP
+					? []
+					: [
+							new Bun.Image(inputBuffer)
+								.resize(width, height)
+								.webp({ quality })
+								.bytes()
+								.then(b => ({ buffer: b, mimeType: "image/webp" })),
+						]),
 			]);
-			return pickSmallest(
-				{ buffer: jpegBuffer, mimeType: "image/jpeg" },
-				{ buffer: webpBuffer, mimeType: "image/webp" },
-			);
+			return pickSmallest(...candidates);
 		}
-
 		// Quality ladder — more aggressive steps for tighter budgets
 		const qualitySteps = [70, 60, 50, 40];
 		const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
@@ -145,7 +170,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		let finalWidth = targetWidth;
 		let finalHeight = targetHeight;
 
-		// First attempt: resize to target, try PNG/JPEG/WebP, pick smallest
+		// First attempt: resize to target, try PNG/JPEG (+ WebP), pick smallest
 		best = await encodeSmallest(targetWidth, targetHeight, opts.jpegQuality);
 
 		if (best.buffer.length <= opts.maxBytes) {
@@ -163,7 +188,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			};
 		}
 
-		// Still too large — lossy ladder (JPEG vs WebP, smallest wins) with decreasing quality
+		// Still too large — lossy JPEG (+ WebP) ladder with decreasing quality
 		for (const quality of qualitySteps) {
 			best = await encodeLossy(targetWidth, targetHeight, quality);
 

package/src/utils/title-generator.ts

@@ -3,7 +3,7 @@
  */
 import * as path from "node:path";
 
-import { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
@@ -16,6 +16,25 @@ const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 const MAX_INPUT_CHARS = 2000;
+const TITLE_MAX_TOKENS = 30;
+const REASONING_SAFE_MAX_TOKENS = 1024;
+const SET_TITLE_TOOL_NAME = "set_title";
+
+const setTitleTool: Tool = {
+	name: SET_TITLE_TOOL_NAME,
+	description: "Set the generated session title.",
+	parameters: {
+		type: "object",
+		properties: {
+			title: {
+				type: "string",
+				description: "A concise 3-6 word title for the session.",
+			},
+		},
+		required: ["title"],
+		additionalProperties: false,
+	},
+};
 
 function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
@@ -76,14 +95,16 @@ ${truncatedMessage}
 	// account_uuid rather than the snapshot-at-call-site value.
 	const metadata = metadataResolver?.(model.provider);
 
-	// Title generation is a 3-6 word task; force reasoning off so reasoning models
-	// don't burn the entire output budget on internal thinking and return an empty
-	// string. With reasoning disabled, 30 tokens of output is plenty.
+	// Title generation is a 3-6 word task, but some reasoning backends ignore
+	// disableReasoning. Keep the normal cheap budget for non-reasoning models
+	// while reserving enough output room for reasoning models to still emit
+	// the forced tool call after any unavoidable thinking tokens.
+	const maxTokens = model.reasoning ? Math.max(TITLE_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : TITLE_MAX_TOKENS;
 	const request = {
 		model: `${model.provider}/${model.id}`,
 		systemPrompt: TITLE_SYSTEM_PROMPT,
 		userMessage,
-		maxTokens: 30,
+		maxTokens,
 	};
 	logger.debug("title-generator: request", request);
 
@@ -93,11 +114,13 @@ ${truncatedMessage}
 			{
 				systemPrompt: [request.systemPrompt],
 				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+				tools: [setTitleTool],
 			},
 			{
 				apiKey,
-				maxTokens: 30,
+				maxTokens: request.maxTokens,
 				disableReasoning: true,
+				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
 				metadata,
 			},
 		);
@@ -111,13 +134,7 @@ ${truncatedMessage}
 			return null;
 		}
 
-		let title = "";
-		for (const content of response.content) {
-			if (content.type === "text") {
-				title += content.text;
-			}
-		}
-		title = title.trim();
+		const title = extractGeneratedTitle(response.content);
 
 		logger.debug("title-generator: response", {
 			model: request.model,
@@ -140,6 +157,21 @@ ${truncatedMessage}
 	}
 }
 
+function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): string {
+	let textTitle = "";
+	for (const content of contentBlocks) {
+		if (content.type === "toolCall" && content.name === SET_TITLE_TOOL_NAME) {
+			const args = content.arguments as Record<string, unknown>;
+			const title = args.title;
+			return typeof title === "string" ? title.trim() : "";
+		}
+		if (content.type === "text") {
+			textTitle += content.text;
+		}
+	}
+	return textTitle.trim();
+}
+
 /**
  * Remove control characters so model-generated titles cannot inject terminal escapes.
  */

package/dist/types/modes/components/status-line-segment-editor.d.ts

@@ -1,24 +0,0 @@
-/**
- * Status Line Segment Editor
- *
- * Interactive component for configuring status line segments.
- * - Three-column layout: Left | Right | Disabled
- * - Space: Toggle segment visibility (disabled ↔ left)
- * - Tab: Cycle segment between columns (left → right → disabled → left)
- * - Shift+J/K: Reorder segment within column
- * - Live preview shown in the actual status line above
- */
-import { Container } from "@oh-my-pi/pi-tui";
-import type { StatusLineSegmentId } from "../../config/settings-schema";
-export interface SegmentEditorCallbacks {
-    onSave: (leftSegments: StatusLineSegmentId[], rightSegments: StatusLineSegmentId[]) => void;
-    onCancel: () => void;
-    onPreview?: (leftSegments: StatusLineSegmentId[], rightSegments: StatusLineSegmentId[]) => void;
-}
-export declare class StatusLineSegmentEditorComponent extends Container {
-    #private;
-    private readonly callbacks;
-    constructor(currentLeft: StatusLineSegmentId[], currentRight: StatusLineSegmentId[], callbacks: SegmentEditorCallbacks);
-    handleInput(data: string): void;
-    render(width: number): string[];
-}