@oh-my-pi/pi-tui 18.2.10 → 18.3.0

package/src/setup/scenes/sign-in.ts

@@ -230,7 +230,7 @@ export class SignInTab implements SetupTab {
 		this.#host.restoreFocus();
 		this.#host.requestRender();
 		try {
-			await this.#authStorage.login(providerId as OAuthProvider, {
+			await this.#authStorage.oauth.login(providerId as OAuthProvider, {
 				signal: this.#loginAbort.signal,
 				onBrowserSession: (request, signal) => this.#host.ctx.captureBrowserSession(request, signal),
 				onAuth: info => {

package/src/status-line/component.ts

@@ -55,6 +55,18 @@ const BRAND_FADE_MS = 450;
 /** Repaint cadence while the brand fade is in flight (rust omp's `FADE_FRAME`). */
 const BRAND_FADE_FRAME_MS = 40;
 
+/**
+ * Providers whose subscription quota is a single monthly bucket, so their
+ * `monthly`/`30d` window is the one the usage segment must show. Providers that
+ * merely report a monthly side-counter (GitHub Copilot's premium requests) stay
+ * out: their monthly row is not the session quota.
+ */
+const MONTHLY_SUBSCRIPTION_PROVIDERS: Record<string, true> = {
+	"alibaba-token-plan": true,
+	cursor: true,
+	"opencode-go": true,
+};
+
 /** A displayable limit after provider, account, model, and window filtering. */
 interface UsageWindowCandidate {
 	id?: string;
@@ -1842,6 +1854,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const activeModelId = normalizeUsageScopeValue(context.modelId);
 		const activeAntigravityCounter =
 			context.provider === "google-antigravity" ? getAntigravityCounterKeyForModel(context.modelId) : undefined;
+		const monthlySubscriptionProvider =
+			context.provider !== undefined && MONTHLY_SUBSCRIPTION_PROVIDERS[context.provider] === true;
 		const scopeGroups = new Map<string, UsageScopeGroup>();
 		for (const report of reports) {
 			if (!report || typeof report !== "object") continue;
@@ -1904,10 +1918,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 										: undefined;
 				const windowClass =
 					subscriptionWindow ??
-					((context.provider === "cursor" || context.provider === "opencode-go") &&
-					(windowId === "monthly" || windowId === "30d")
-						? "monthly"
-						: undefined);
+					(monthlySubscriptionProvider && (windowId === "monthly" || windowId === "30d") ? "monthly" : undefined);
 				if (!windowClass) continue;
 
 				const modelId = normalizeUsageScopeValue("modelId" in scope ? scope.modelId : undefined);

package/src/status-line/context-usage.ts

@@ -2,6 +2,7 @@ import type { AgentMessage, Tokenizer } from "@oh-my-pi/pi-agent-core";
 import type { CompactionSettings } from "@oh-my-pi/pi-agent-core/compaction";
 import { effectiveReserveTokens, resolveThresholdTokens } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Tool as AiTool, Model } from "@oh-my-pi/pi-ai";
+import { renderToolExamples } from "@oh-my-pi/pi-ai/dialect";
 import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../theme";
@@ -12,7 +13,7 @@ interface ContextSkill {
 	readonly hide?: boolean;
 }
 
-type ContextTool = Pick<AiTool, "name" | "description" | "parameters">;
+type ContextTool = Pick<AiTool, "name" | "description" | "parameters" | "examples">;
 
 /** Savings computed by the host's inline-image planner, not by the renderer. */
 export interface ContextSavingsEstimate {
@@ -140,6 +141,8 @@ export interface NonMessageTokenSource {
 		};
 	};
 	readonly skills?: readonly ContextSkill[];
+	/** Provider-facing, session-frozen descriptions when available. */
+	readonly renderedSkills?: readonly ContextSkill[];
 }
 
 /** Shared empty system-prompt part list, avoiding an allocation per render. */
@@ -244,9 +247,13 @@ export function estimateToolSchemaTokens(tools: ToolSchemaSource, tokenizer: Tok
 				name,
 				description,
 				parameters: parameters as AiTool["parameters"],
+				examples: tool.examples,
 			};
 			const wireJson = JSON.stringify(toolWireSchema(wireTool) ?? {});
 			if (typeof wireJson === "string") fragments.push(wireJson);
+			// The agent loop appends rendered examples to the wire description.
+			const examplesBlock = renderToolExamples(wireTool);
+			if (examplesBlock) fragments.push(examplesBlock);
 		} catch {
 			// Schema may contain functions or cycles; ignore.
 		}
@@ -313,7 +320,7 @@ function nonMessageTokenCacheEntry(
 	const systemPromptRef = session.systemPrompt ?? EMPTY_STRING_PARTS;
 	const toolsRef = session.agent?.state?.tools ?? EMPTY_TOOLS;
 	const toolsRevision = getToolSchemaMetadataRevision(toolsRef);
-	const skillsRef = session.skills ?? EMPTY_SKILLS;
+	const skillsRef = session.renderedSkills ?? session.skills ?? EMPTY_SKILLS;
 	let entry = cachedSession[NON_MESSAGE_TOKEN_CACHE];
 	if (
 		entry &&
@@ -378,7 +385,12 @@ export function computeNonMessageBreakdown(
 	if (entry.breakdown && entry.skillful === skillful) return entry.breakdown;
 	const tools = session.agent?.state?.tools ?? EMPTY_TOOLS;
 	const skillsTokens =
-		skillful === false ? 0 : estimateSkillsTokens(renderedSkills(session.skills ?? EMPTY_SKILLS, tools), tokenizer);
+		skillful === false
+			? 0
+			: estimateSkillsTokens(
+					renderedSkills(session.renderedSkills ?? session.skills ?? EMPTY_SKILLS, tools),
+					tokenizer,
+				);
 	const toolsTokens = estimateToolSchemaTokens(tools, tokenizer, sourceRevision);
 	const systemPromptParts = session.systemPrompt ?? EMPTY_STRING_PARTS;
 	const systemContextTokens = tokenizer.countTokens(Array.from(systemPromptParts.slice(1), part => part ?? ""));

package/src/status-line/segments.ts

@@ -881,9 +881,9 @@ const usageSegment: StatusLineSegment = {
 			parts.push(formatQuotaWindow(ctx, "7d", u.sevenDay.percent, u.sevenDay.resetHours, "h", "round"));
 		}
 		if (u.monthly) {
-			// Cursor and OpenCode Go (normalize gates monthly to those providers).
-			// Both floor used percents upstream (Cursor's dashboard shows 1.88 →
-			// "1% used"; OpenCode's endpoint already emits floored integers).
+			// Monthly-subscription providers only (the normalizer gates the class).
+			// Cursor and QwenCloud floor used percents upstream (Cursor's dashboard
+			// shows 1.88 → "1% used"; OpenCode's endpoint emits floored integers).
 			parts.push(formatQuotaWindow(ctx, "mo", u.monthly.percent, u.monthly.resetHours, "h", "floor"));
 		}
 		if (u.resetCredits) {

package/src/terminal-capabilities.ts

@@ -42,7 +42,7 @@ export type TerminalId =
 	| "base"
 	| "trueColor";
 
-const CMUX_NOTIFICATION_TITLE = "Oh My Pi";
+const CMUX_NOTIFICATION_TITLE = "omp";
 const CMUX_SURFACE_ID_PATTERN = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/iu;
 
 /** Title and body for an out-of-band multiplexer notification (cmux, Herdr). */
@@ -678,11 +678,20 @@ const KNOWN_TERMINALS = Object.freeze({
 	// OSC 66 text sizing are unverified, so those stay on conservative defaults;
 	// synchronized output is left to the runtime DECRQM probe.
 	otty: new TerminalInfo("otty", ImageProtocol.Kitty, true, true, NotifyProtocol.Osc99),
-	// rio ships the Kitty graphics protocol — direct placement plus U=1 Unicode
-	// placeholders verified by the reporter (#12205). Everything unproven stays
-	// conservative: hyperlinks, DECCARA, screen-to-scrollback, and notifications
-	// keep the base defaults until verified in that terminal.
-	rio: new TerminalInfo("rio", ImageProtocol.Kitty, true, false),
+	// rio publishes its supported escape sequences at
+	// rioterm.com/docs/escape-sequence-support: OSC 8 hyperlinks are opened via
+	// the hints system (Alt+click on Windows/Linux) — live-verified on
+	// rio 0.5.28/Win11 26100 where an OSC 8 span Alt+click opened the target
+	// URL in the browser, and an OSC 52 clipboard query round-tripped. Kitty
+	// graphics direct placement plus U=1 Unicode placeholders verified by the
+	// reporter (#12205). Notifications stay on BEL: rio parses OSC 9/777 into
+	// its own notifier, but its Windows path raises an unpackaged WinRT toast
+	// with AppId "Rio" that Windows silently drops without a registered AUMID
+	// shortcut — observed as a no-op live — so flipping it would only remove
+	// the D-Bus fallback for Linux rio users. DECCARA, screen-to-scrollback,
+	// OSC 99, and OSC 66 text sizing are outside rio's supported set and keep
+	// the conservative defaults.
+	rio: new TerminalInfo("rio", ImageProtocol.Kitty, true, true),
 });
 
 /** Resolve terminal identity from environment markers used by common emulators. */
@@ -1424,7 +1433,7 @@ function notificationToLine(n: TerminalNotification): string {
 // C0/C1 control characters that are unsafe inside an OSC payload (must base64).
 const OSC99_UNSAFE = /[\x00-\x1f\x7f\x80-\x9f]/u;
 const OSC99_MAX_PAYLOAD_BYTES = 2048;
-const OSC99_APP_NAME = "Oh My Pi";
+const OSC99_APP_NAME = "omp";
 let nextOsc99NotificationId = 1;
 
 function base64Utf8(value: string): string {

package/src/terminal.ts

@@ -25,6 +25,7 @@ import {
 } from "./terminal-capabilities";
 import { isInsideTmux, wrapTmuxPassthrough } from "./tmux";
 import { setHangulCompatibilityJamoWidth } from "./utils";
+import { translateWindowsAltGrSequence } from "./windows-altgr";
 
 const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
 const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
@@ -1463,7 +1464,13 @@ export class ProcessTerminal implements Terminal {
 				return;
 			}
 			if (this.#inputHandler) {
-				this.#inputHandler(sequence);
+				// Windows console hosts drop AltGr text under kitty (AltGr+F → `CSI 102;3u`);
+				// recover it from the active layout before any keybinding sees an Alt chord.
+				const altGrText =
+					this.#kittyProtocolActive && this.#conpty && process.platform === "win32"
+						? translateWindowsAltGrSequence(sequence)
+						: undefined;
+				this.#inputHandler(altGrText ?? sequence);
 			}
 		});
 

package/src/theme/mermaid-cache.ts

@@ -1,5 +1,5 @@
 import type { MermaidRenderOptions } from "@oh-my-pi/pi-natives";
-import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
+import * as mermaidAscii from "@oh-my-pi/pi-utils/mermaid-ascii";
 
 /**
  * Options controlling how fenced Mermaid source is resolved to terminal ASCII.
@@ -8,12 +8,10 @@ import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
  */
 export interface MermaidResolveOptions extends MermaidRenderOptions {
 	/**
-	 * Maximum display width (terminal columns) the diagram should occupy. A
-	 * layout that overflows this width is re-rendered in the perpendicular
-	 * orientation — a wide horizontal chain collapses to a tall vertical column
-	 * (which the terminal can scroll), and a wide vertical fan-out collapses to a
-	 * tall horizontal column. Omit to keep the source's own layout regardless of
-	 * width.
+	 * Maximum display width (terminal columns) the diagram should occupy.
+	 * Flowcharts are also rendered top-down and left-to-right. A resize picks
+	 * the shortest variant that fits; if none fit, the narrowest, which the
+	 * caller may still clip. Omit to keep the source's own layout.
 	 */
 	maxWidth?: number;
 }
@@ -23,16 +21,29 @@ export interface MermaidResolveOptions extends MermaidRenderOptions {
 // the cached renders, so a terminal resize re-decides without re-rendering.
 const cache = new Map<string, string | null>();
 
-/** Widest rendered row in display columns (ANSI- and CJK-aware). */
+/** Display columns, ignoring ANSI so themed diagrams are measured as drawn. */
+const DISPLAY_WIDTH = { countAnsiEscapeCodes: false } as const;
+
 function asciiDisplayWidth(ascii: string): number {
 	let max = 0;
 	for (const line of ascii.split("\n")) {
-		const width = Bun.stringWidth(line);
+		const width = Bun.stringWidth(line, DISPLAY_WIDTH);
 		if (width > max) max = width;
 	}
 	return max;
 }
 
+interface LayoutCandidate {
+	ascii: string;
+	width: number;
+	height: number;
+	authored: boolean;
+}
+
+function measureLayout(ascii: string, authored: boolean): LayoutCandidate {
+	return { ascii, width: asciiDisplayWidth(ascii), height: ascii.split("\n").length, authored };
+}
+
 function renderVariant(
 	source: string,
 	baseOptions: MermaidRenderOptions,
@@ -43,11 +54,39 @@ function renderVariant(
 	const cached = cache.get(key);
 	if (cached !== undefined) return cached;
 
-	const ascii = renderMermaidAsciiSafe(source, direction ? { ...baseOptions, direction } : baseOptions);
+	const ascii = mermaidAscii.renderMermaidAsciiSafe(source, direction ? { ...baseOptions, direction } : baseOptions);
 	cache.set(key, ascii);
 	return ascii;
 }
 
+const FORCED_DIRECTIONS = ["TD", "LR"] as const;
+type ForcedDirection = (typeof FORCED_DIRECTIONS)[number];
+
+/**
+ * Forced TD/LR renders that can differ from the authored one. Sequence, class,
+ * ER, and xychart ignore direction, so they get none; header match mirrors
+ * native `detect_diagram_kind`, including its JavaScript `\w` boundary
+ * (`[A-Za-z0-9_]`). A `graph`/`flowchart` header already authored in one of
+ * the forced layouts (`TD`/`TB` lay out as TD, `LR`/`RL` as LR) skips that
+ * variant: the native override replaces the header direction, so the render
+ * would be byte-identical to the authored one.
+ */
+function forcedDirections(source: string): readonly ForcedDirection[] {
+	const header = (source.split("\n", 1)[0] ?? "").trim().toLowerCase();
+	for (const prefix of ["xychart-beta", "xychart"] as const) {
+		if (!header.startsWith(prefix)) continue;
+		const next = header.charCodeAt(prefix.length);
+		const wordChar =
+			(next >= 48 && next <= 57) || (next >= 65 && next <= 90) || (next >= 97 && next <= 122) || next === 95;
+		if (!wordChar) return [];
+	}
+	if (header === "sequencediagram" || header === "classdiagram" || header === "erdiagram") return [];
+	const authored = /^(?:graph|flowchart)\s+(td|tb|lr|rl)$/.exec(header)?.[1];
+	if (authored === "td" || authored === "tb") return ["LR"];
+	if (authored === "lr" || authored === "rl") return ["TD"];
+	return FORCED_DIRECTIONS;
+}
+
 /**
  * Resolve mermaid ASCII from fenced block source text.
  * Returns null when rendering fails, while memoizing failures to avoid repeated work.
@@ -65,24 +104,43 @@ export function resolveMermaidAscii(source: string, options?: MermaidResolveOpti
 	if (base === null) return null;
 	if (maxWidth === undefined) return base;
 
-	let best = base;
-	let bestWidth = asciiDisplayWidth(base);
-	if (bestWidth <= maxWidth) return base;
-
-	// The as-authored layout overflows. Render both forced orientations and keep
-	// the narrowest (clipping at the call site handles any residual overflow).
-	// Re-rendering the already-authored orientation is a cache hit, so this stays
-	// cheap, and one of the two will be the perpendicular fit.
-	for (const direction of ["TD", "LR"] as const) {
+	// Width selection is against cached renders, so a later resize re-decides
+	// without drawing again. Only forced layouts that can differ from the
+	// authored one are rendered (see `forcedDirections`).
+	const candidates = [measureLayout(base, true)];
+	for (const direction of forcedDirections(normalizedSource)) {
 		const variant = renderVariant(normalizedSource, baseOptions, baseKey, direction);
-		if (variant === null) continue;
-		const variantWidth = asciiDisplayWidth(variant);
-		if (variantWidth < bestWidth) {
-			best = variant;
-			bestWidth = variantWidth;
+		if (variant !== null) candidates.push(measureLayout(variant, false));
+	}
+
+	const fitting = candidates.filter(candidate => candidate.width <= maxWidth);
+	const pool = fitting.length > 0 ? fitting : candidates;
+	let best = pool[0]!;
+	for (let i = 1; i < pool.length; i++) {
+		const next = pool[i]!;
+		if (fitting.length > 0) {
+			if (next.height !== best.height) {
+				if (next.height < best.height) best = next;
+				continue;
+			}
+			if (next.authored !== best.authored) {
+				if (next.authored) best = next;
+				continue;
+			}
+			if (next.width < best.width) best = next;
+			continue;
+		}
+		if (next.width !== best.width) {
+			if (next.width < best.width) best = next;
+			continue;
+		}
+		if (next.height !== best.height) {
+			if (next.height < best.height) best = next;
+			continue;
 		}
+		if (next.authored) best = next;
 	}
-	return best;
+	return best.ascii;
 }
 
 /**

package/src/tools/bash.ts

@@ -41,6 +41,13 @@ export interface BashToolDetails {
 	timedOut?: boolean;
 	/** Live ACP update only; completed results refer to released terminals. */
 	terminalId?: string;
+	service?: {
+		name: string;
+		state: string;
+		ready: boolean;
+		timedOut: boolean;
+		pid?: number;
+	};
 	async?: {
 		state: "running" | "completed" | "failed";
 		jobId: string;
@@ -362,6 +369,12 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 					if (details?.async?.state === "running") {
 						statsParts.push(`Backgrounded: ${details.async.jobId}`);
 					}
+					if (details?.service) {
+						const service = details.service;
+						statsParts.push(`Service: ${service.name}`, `State: ${service.state}`);
+						statsParts.push(`Ready: ${service.ready ? "yes" : service.timedOut ? "timed out" : "no"}`);
+						if (service.pid !== undefined) statsParts.push(`PID: ${service.pid}`);
+					}
 					if (wallTimeMs !== undefined) {
 						statsParts.push(`Wall: ${formatWallTimeSeconds(wallTimeMs)}s`);
 					}
@@ -460,7 +473,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 
 /** Renders bash command previews and output. */
 export const bashToolRenderer = createShellRenderer<BashRenderArgs>({
-	resolveTitle: () => "Bash",
+	resolveTitle: args => (args?.name ? `Bash · ${String(args.name)}` : "Bash"),
 	resolveCommand: args => args?.command,
 	resolveCwd: args => args?.cwd,
 	resolveEnv: args => args?.env,

package/src/tools/daemon.ts

@@ -0,0 +1,51 @@
+/** Launch-broker daemon types shared by services, `proc://`, and `omp ps`. */
+
+/** Stable lifecycle states exposed by the launch broker. */
+export type DaemonState = "starting" | "running" | "ready" | "restarting" | "stopping" | "exited" | "failed";
+
+/** Restart behavior applied after an unexpected daemon exit. */
+export type DaemonRestartPolicy = "no" | "on-failure" | "always";
+
+/** Readiness conditions; every configured condition must pass. */
+export interface DaemonReadySpec {
+	log?: string;
+	port?: number;
+	host?: string;
+	timeoutMs: number;
+}
+
+/** Immutable launch specification retained for restart and inspection. */
+export interface DaemonSpec {
+	name: string;
+	application: string;
+	args: string[];
+	env: Record<string, string>;
+	cwd: string;
+	pty: boolean;
+	ready?: DaemonReadySpec;
+	restart: DaemonRestartPolicy;
+	persist: boolean;
+	detached: boolean;
+}
+
+/** Serializable daemon state visible to every client in one broker scope. */
+export interface DaemonSnapshot {
+	name: string;
+	id: string;
+	state: DaemonState;
+	pid?: number;
+	createdAt: number;
+	startedAt: number;
+	readyAt?: number;
+	exitedAt?: number;
+	exitCode?: number;
+	exitReason?: string;
+	restartCount: number;
+	outputBytes: number;
+	owner?: string;
+	readyMatch?: string;
+	/** Readiness conditions still unmet while `state` is `starting`; absent once ready or without a ready spec. */
+	readyPending?: ("log" | "port")[];
+	persist: boolean;
+	detached: boolean;
+}

package/src/tools/index.ts

@@ -15,7 +15,7 @@ import { githubToolRenderer } from "./github";
 import { globToolRenderer } from "./glob";
 import { goalToolRenderer } from "./goal";
 import { grepToolRenderer } from "./grep";
-import { hubToolRenderer } from "./hub";
+import { waitToolRenderer } from "./wait";
 import { lspToolRenderer } from "./lsp";
 import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory";
 import { readToolRenderer } from "./read";
@@ -45,7 +45,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	glob: globToolRenderer,
 	grep: grepToolRenderer,
 	lsp: lspToolRenderer,
-	hub: hubToolRenderer,
+	wait: waitToolRenderer,
 	read: readToolRenderer,
 	// Keyed by xd:// resolution-device names: the write dispatch delegates here
 	// by dispatch tool, and historical `resolve` tool transcripts still render

package/src/tools/irc.ts

@@ -0,0 +1,33 @@
+/** Peer-message types and roster constants shared by messaging, `wait`, and child prompts. */
+
+/** Maximum live peer rows embedded in child prompts. */
+export const DEFAULT_PEER_ROSTER_LIMIT = 32;
+
+/** Serializable peer message retained in coordination result snapshots. */
+export interface IrcMessage {
+	id: string;
+	/** Sender agent id. */
+	from: string;
+	/** Recipient agent id (resolved; "all" is expanded by the tool, not stored). */
+	to: string;
+	body: string;
+	ts: number;
+	/** Message id being answered. */
+	replyTo?: string;
+	/**
+	 * Automated wake-turn relay of a woken subagent's stop output (task executor
+	 * `relayWakeTurnOutput`). Relays are answers, never wake sources: the
+	 * recipient's own wake-turn relay must skip them or two idle peers
+	 * ping-pong forever.
+	 */
+	wakeRelay?: boolean;
+}
+
+/** Delivery outcome for one peer recipient. */
+export interface IrcDeliveryReceipt {
+	to: string;
+	outcome: "injected" | "woken" | "revived" | "failed";
+	error?: string;
+}
+/** Status ordering for peer rosters in child prompts. */
+export const LIST_STATUS_ORDER: Record<string, number> = { running: 0, idle: 1, parked: 2 };

package/src/tools/line-ranges.ts

@@ -15,6 +15,11 @@ const LINE_RANGE_CHUNK_RE = new RegExp(`^${LINE_RANGE_CHUNK_SOURCE}$`, "i");
 
 /** Parse a single `N`, `N-M`, `N-`, `N+K`, or `..`-aliased (`N..M`, `N..`) chunk. Throws via {@link ToolError} on invalid bounds. */
 export function parseLineRangeChunk(sel: string): LineRange | null {
+	return parseChunk(sel, false);
+}
+
+/** `pinBare` makes a separator-less `N` the single line `N` instead of "from `N` onward". */
+function parseChunk(sel: string, pinBare: boolean): LineRange | null {
 	const lineMatch = LINE_RANGE_CHUNK_RE.exec(sel);
 	if (!lineMatch) return null;
 	const rawStart = Number.parseInt(lineMatch[1]!, 10);
@@ -31,27 +36,32 @@ export function parseLineRangeChunk(sel: string): LineRange | null {
 		}
 		rawEnd = rawStart + rhs - 1;
 	} else if (sep === "-") {
-		// `301-` is shorthand for "from 301 onward" — equivalent to bare `301`.
+		// `301-` is shorthand for "from 301 onward" — equivalent to a lone bare `301`.
 		if (rhs !== undefined) {
 			if (rhs < rawStart) {
 				throw new ToolError(`Invalid range ${rawStart}-${rhs}: end must be >= start.`);
 			}
 			rawEnd = rhs;
 		}
+	} else if (pinBare) {
+		rawEnd = rawStart;
 	}
 	return { startLine: rawStart, endLine: rawEnd };
 }
 
 /**
- * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns
+ * Parse a comma-separated list of line ranges (e.g. `5-16,960-973` or `19,59`). Returns
  * the ranges in ascending order with overlapping/adjacent ranges merged so
  * downstream consumers can stream the file in a single forward pass per range.
  */
 export function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null {
 	const chunks = sel.split(",");
+	// A lone `:50` means "from line 50". Inside a comma list, a bare number is
+	// that one line; otherwise `:19,59` collapses to "from 19 through EOF".
+	const pinBare = chunks.length > 1;
 	const parsed: LineRange[] = [];
 	for (const chunk of chunks) {
-		const range = parseLineRangeChunk(chunk);
+		const range = parseChunk(chunk, pinBare);
 		if (!range) return null;
 		parsed.push(range);
 	}