@oh-my-pi/pi-coding-agent 16.4.2 → 16.4.3

package/src/extensibility/plugins/legacy-pi-virtual-modules.d.ts

@@ -0,0 +1,4 @@
+declare module "omp-legacy-pi-modules" {
+	/** Host package namespaces retained by the compiled binary for legacy extensions. */
+	export const BUNDLED_PI_MODULES: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}

package/src/internal-urls/docs-index.ts

@@ -16,7 +16,8 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import { gunzip } from "node:zlib";
 import { Glob } from "bun";
-import docsEmbed from "./docs-index.generated.txt";
+
+const docsEmbed = process.env.PI_DOCS_EMBED ?? "";
 
 const gunzipAsync = promisify(gunzip);
 

package/src/internal-urls/skill-protocol.ts

@@ -72,7 +72,7 @@ export class SkillProtocolHandler implements ProtocolHandler {
 				throw new Error("Path traversal is not allowed");
 			}
 		} else {
-			targetPath = skill.filePath;
+			targetPath = context?.pathOnly === true ? skill.baseDir : skill.filePath;
 		}
 
 		let stats: fsTypes.Stats;

package/src/lsp/deferred-diagnostics.ts

@@ -0,0 +1,66 @@
+import type { DeferredDiagnosticsEntry, ToolSession } from "../tools";
+import { getDiagnosticsLedger } from "./diagnostics-ledger";
+import type { FileDiagnosticsResult, WritethroughDeferredHandle } from "./index";
+
+/** Coordinates late LSP diagnostics for one mutation tool instance. */
+export class DeferredDiagnostics {
+	readonly #pendingFetches = new Map<string, AbortController>();
+	readonly #fallbackVersions = new Map<string, number>();
+
+	constructor(
+		private readonly session: ToolSession,
+		private readonly deduplicate: boolean,
+	) {}
+
+	/** Begin a file mutation and return the handle consumed by LSP writethrough. */
+	begin(path: string): WritethroughDeferredHandle {
+		const existing = this.#pendingFetches.get(path);
+		if (existing) {
+			existing.abort();
+			this.#pendingFetches.delete(path);
+		}
+
+		const controller = new AbortController();
+		const mutationVersion = this.#bumpVersion(path);
+		return {
+			onDeferredDiagnostics: diagnostics => {
+				this.#pendingFetches.delete(path);
+				this.#inject(path, diagnostics, mutationVersion);
+			},
+			signal: controller.signal,
+			finalize: diagnostics => {
+				if (!diagnostics) {
+					this.#pendingFetches.set(path, controller);
+				} else {
+					controller.abort();
+				}
+			},
+		};
+	}
+
+	#inject(path: string, diagnostics: FileDiagnosticsResult, mutationVersion: number): void {
+		const effective = this.deduplicate ? getDiagnosticsLedger(this.session).reduce(path, diagnostics) : diagnostics;
+		if (this.deduplicate && effective.messages.length === 0) return;
+
+		const entry: DeferredDiagnosticsEntry = {
+			path,
+			summary: effective.summary ?? "",
+			messages: effective.messages ?? [],
+			errored: effective.errored,
+			isStale: () => this.#version(path) !== mutationVersion,
+		};
+		this.session.queueDeferredDiagnostics?.(entry);
+	}
+
+	#bumpVersion(path: string): number {
+		if (this.session.bumpFileMutationVersion) return this.session.bumpFileMutationVersion(path);
+		const next = (this.#fallbackVersions.get(path) ?? 0) + 1;
+		this.#fallbackVersions.set(path, next);
+		return next;
+	}
+
+	#version(path: string): number {
+		if (this.session.getFileMutationVersion) return this.session.getFileMutationVersion(path);
+		return this.#fallbackVersions.get(path) ?? 0;
+	}
+}

package/src/main.ts

@@ -78,9 +78,10 @@ import { concreteThinkingLevel, parseConfiguredThinkingLevel } from "./thinking"
 import type { LspStartupServerInfo } from "./tools";
 import {
 	getChangelogPath,
-	getNewEntries,
 	parseChangelog,
+	parseChangelogVersion,
 	readLastChangelogVersion,
+	selectStartupChangelog,
 	writeLastChangelogVersion,
 } from "./utils/changelog";
 import { EventBus } from "./utils/event-bus";
@@ -610,6 +611,11 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 	}
 
 	const lastVersion = await readLastChangelogVersion();
+	const parsedLastVersion = parseChangelogVersion(lastVersion);
+	if (!parsedLastVersion) {
+		await writeLastChangelogVersion(VERSION);
+		return undefined;
+	}
 	if (lastVersion === VERSION) {
 		// Steady state: user already saw the current version's changelog. Skip the file read + parse.
 		return undefined;
@@ -617,18 +623,12 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 
 	const changelogPath = getChangelogPath();
 	const entries = await parseChangelog(changelogPath);
-
-	if (!lastVersion) {
-		if (entries.length > 0) {
-			await writeLastChangelogVersion(VERSION);
-			return entries.map(e => e.content).join("\n\n");
-		}
-	} else {
-		const newEntries = getNewEntries(entries, lastVersion);
-		if (newEntries.length > 0) {
-			await writeLastChangelogVersion(VERSION);
-			return newEntries.map(e => e.content).join("\n\n");
-		}
+	const startupChangelog = selectStartupChangelog(entries, lastVersion, VERSION);
+	if (startupChangelog.persistCurrentVersion) {
+		await writeLastChangelogVersion(VERSION);
+	}
+	if (startupChangelog.markdown) {
+		return startupChangelog.markdown;
 	}
 
 	return undefined;

package/src/mcp/transports/stdio.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test";
+import { describe, expect, it, spyOn } from "bun:test";
 
 import { resolveStdioSpawnCommand, StdioTransport } from "./stdio";
 
@@ -56,6 +56,50 @@ describe("resolveStdioSpawnCommand", () => {
 	});
 });
 
+describe("StdioTransport.connect", () => {
+	it("passes argv as Bun.spawn's first argument and process options as the second", async () => {
+		const cwd = process.cwd();
+		const envValue = "stdio-spawn-shape";
+		const argv = [process.execPath, "-e", "process.exit(0)"];
+		const transport = new StdioTransport({
+			command: argv[0],
+			args: argv.slice(1),
+			cwd,
+			env: {
+				OMP_STDIO_SPAWN_SHAPE: envValue,
+			},
+		});
+		const spawnSpy = spyOn(Bun, "spawn");
+
+		try {
+			await transport.connect();
+
+			expect(spawnSpy).toHaveBeenCalledTimes(1);
+			const call = spawnSpy.mock.calls[0];
+			if (!call) throw new Error("expected StdioTransport.connect() to spawn exactly one subprocess");
+
+			const [spawnArgv, spawnOptions] = call;
+			expect(spawnArgv).toEqual(argv);
+			expect(spawnOptions).toEqual(
+				expect.objectContaining({
+					cwd,
+					detached: !(process.platform === "darwin" || process.platform === "win32"),
+					env: expect.objectContaining({
+						OMP_STDIO_SPAWN_SHAPE: envValue,
+					}),
+					stderr: "pipe",
+					stdin: "pipe",
+					stdout: "pipe",
+					windowsHide: process.platform === "win32" ? expect.any(Boolean) : undefined,
+				}),
+			);
+		} finally {
+			await transport.close();
+			spawnSpy.mockRestore();
+		}
+	});
+});
+
 // Regression for #3945: request() awaited stdin.write/flush, so a child that
 // stops draining stdin would park the async fn past the timeout timer and past
 // `return promise`, orphaning the deferred rejection and hanging the caller

package/src/mcp/transports/stdio.ts

@@ -8,7 +8,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getProjectDir, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
-import { type Subprocess, spawn } from "bun";
+import type { Subprocess } from "bun";
 import { hostHasInheritableConsole } from "../../eval/py/spawn-options";
 import type {
 	JsonRpcError,
@@ -376,8 +376,11 @@ export class StdioTransport implements MCPTransport {
 		// macOS stays attached so TCC can prompt for Apple Events automation;
 		// Windows stays attached, and only hides the child when the host has no
 		// console to share. See `StdioSpawnCommand`.
-		this.#process = spawn({
-			cmd: spawnCommand.cmd,
+		// Keep this on Bun's argv-first overload. The eval JS kernel path that
+		// triggers macOS Apple Events TCC prompts uses the same shape; the
+		// one-object `{ cmd }` overload timed out before prompting for `mcpbridge`
+		// even with `detached: false` (#5085).
+		this.#process = Bun.spawn(spawnCommand.cmd, {
 			cwd,
 			env,
 			stdin: "pipe",

package/src/modes/acp/acp-agent.ts

@@ -129,6 +129,15 @@ type PromptLifecycleError = Error & { readonly code: "ACP_SESSION_CLOSED" };
 type PromptTurnState = {
 	cancelRequested: boolean;
 	settled: boolean;
+	/**
+	 * Delivery of streamed assistant `error` chunks this turn (the mapper
+	 * surfaces them as `agent_message_chunk`s). Resolves `true` once at least
+	 * one error chunk reached the client — the `agent_end` error fallback in
+	 * {@link AcpAgent##flushUnreportedTurnError} awaits it and stays silent on
+	 * success, so a fallback racing an in-flight delivery can neither duplicate
+	 * the error nor drop it when delivery fails.
+	 */
+	errorTextDelivery: Promise<boolean> | undefined;
 	/**
 	 * `abort()` is in-flight (or its bounded-timeout race). `undefined` while the turn is
 	 * running normally and after cleanup completes. The turn occupies `record.promptTurn`
@@ -684,6 +693,7 @@ export class AcpAgent implements Agent {
 			record.promptTurn = {
 				cancelRequested: false,
 				settled: false,
+				errorTextDelivery: undefined,
 				cleanup: undefined,
 				usageBaseline: this.#cloneUsageStatistics(record.session.sessionManager.getUsageStatistics()),
 				unsubscribe: undefined,
@@ -1200,6 +1210,10 @@ export class AcpAgent implements Agent {
 			imageDataCache.set(key, resolved);
 			return resolved;
 		};
+		const streamedAssistantError =
+			event.type === "message_update" &&
+			event.message.role === "assistant" &&
+			event.assistantMessageEvent.type === "error";
 		for (const notification of mapAgentSessionEventToAcpSessionUpdates(event, record.session.sessionId, {
 			getMessageId: message => this.#getLiveMessageId(record, message),
 			getMessageProgress: message => this.#getLiveMessageProgress(record, message),
@@ -1207,7 +1221,18 @@ export class AcpAgent implements Agent {
 			cwd: record.session.sessionManager.getCwd(),
 			resolveImageData: resolveImageDataForAcp,
 		})) {
-			await this.#connection.sessionUpdate(notification);
+			const delivery = this.#connection.sessionUpdate(notification);
+			if (streamedAssistantError) {
+				// Resolves true only once the error chunk actually reached the
+				// client — a failed delivery keeps the agent_end fallback armed.
+				const outcome = delivery.then(
+					() => true,
+					() => false,
+				);
+				const prior = promptTurn.errorTextDelivery;
+				promptTurn.errorTextDelivery = prior ? Promise.all([prior, outcome]).then(([a, b]) => a || b) : outcome;
+			}
+			await delivery;
 		}
 		if (event.type === "tool_execution_end") {
 			record.toolArgsById.delete(event.toolCallId);
@@ -1216,6 +1241,7 @@ export class AcpAgent implements Agent {
 
 		if (event.type === "agent_end") {
 			await this.#flushMissedFinalAssistantText(record, event);
+			await this.#flushUnreportedTurnError(record, event);
 			await this.#emitEndOfTurnUpdates(record);
 			await this.#waitForAcpPromptIdle(record);
 			record.liveMessageId = undefined;
@@ -1272,6 +1298,44 @@ export class AcpAgent implements Agent {
 		});
 	}
 
+	/**
+	 * Surface a turn-fatal provider error that never reached the client. A
+	 * request that fails before streaming any assistant events — e.g. GitHub
+	 * Copilot's `HTTP 400 model_not_supported` after retries — emits only
+	 * `agent_end` with an empty assistant message carrying `errorMessage`
+	 * (`Agent#runLoop`'s catch), so no `message_update`/`message_end` ever maps
+	 * to a session update and the client sees the turn end silently. Errors
+	 * that did stream are tracked via {@link PromptTurnState.errorTextDelivery};
+	 * the fallback awaits that delivery and re-sends only when it failed.
+	 */
+	async #flushUnreportedTurnError(
+		record: ManagedSessionRecord,
+		event: Extract<AgentSessionEvent, { type: "agent_end" }>,
+	): Promise<void> {
+		const streamedDelivery = record.promptTurn?.errorTextDelivery;
+		if (streamedDelivery && (await streamedDelivery)) {
+			return;
+		}
+		const lastAssistant = [...event.messages]
+			.reverse()
+			.find((message): message is AssistantMessage => message.role === "assistant");
+		if (lastAssistant?.stopReason !== "error") {
+			return;
+		}
+		const errorMessage = lastAssistant.errorMessage;
+		if (!errorMessage || isSilentAbort(lastAssistant)) {
+			return;
+		}
+		await this.#connection.sessionUpdate({
+			sessionId: record.session.sessionId,
+			update: {
+				sessionUpdate: "agent_message_chunk",
+				content: { type: "text", text: errorMessage },
+				messageId: record.liveMessageId ?? crypto.randomUUID(),
+			},
+		});
+	}
+
 	async #waitForAcpPromptIdle(record: ManagedSessionRecord): Promise<void> {
 		for (let pass = 0; pass < ACP_ASYNC_DELIVERY_DRAIN_MAX_PASSES; pass++) {
 			await record.session.waitForIdle();

package/src/modes/acp/acp-event-mapper.ts

@@ -284,6 +284,11 @@ function mapAssistantMessageUpdate(
 		case "error":
 			sessionUpdate = "agent_message_chunk";
 			text = event.assistantMessageEvent.error.errorMessage ?? "Unknown error";
+			// The surfaced error is the message's visible text: keeps the
+			// message_end / agent_end fallbacks from emitting again.
+			if (text.length > 0 && progress) {
+				progress.textEmitted = true;
+			}
 			break;
 		default:
 			return [];

package/src/modes/acp/acp-mode.ts

@@ -14,6 +14,17 @@ export function createAcpConnection(
 }
 
 export async function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never> {
+	// Humans who run `omp acp` by hand see a silent process and assume it is
+	// broken (stdout is the JSON-RPC transport, so nothing may be printed
+	// there). When stdin is a TTY no ACP client is attached — say so on stderr
+	// before the transport starts.
+	if (process.stdin.isTTY) {
+		process.stderr.write(
+			"omp acp: ACP server speaking JSON-RPC over stdio.\n" +
+				'This command is meant to be spawned by an ACP client (e.g. Zed\'s "agent_servers" config), not run directly.\n' +
+				"Waiting for protocol frames on stdin; logs: ~/.omp/logs/\n",
+		);
+	}
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);

package/src/modes/components/__tests__/move-overlay.test.ts

@@ -3,12 +3,14 @@ import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { visibleWidth } from "@oh-my-pi/pi-tui";
 import { Settings } from "../../../config/settings";
 import { getThemeByName, setThemeInstance, type Theme } from "../../theme/theme";
 import { MoveOverlay, type MoveOverlayResult, resolveExistingDirectory, resolveMovePath } from "../move-overlay";
 
 // Strip SGR colors so assertions see visible text only.
-const strip = (lines: readonly string[]): string => lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+const stripAnsi = (text: string): string => text.replace(/\x1b\[[0-9;]*m/g, "");
+const strip = (lines: readonly string[]): string => lines.map(stripAnsi).join("\n");
 
 describe("resolveMovePath", () => {
 	it("expands ~ to homedir", () => {
@@ -82,6 +84,19 @@ describe("MoveOverlay", () => {
 		expect(text).toContain("Path:");
 	});
 
+	it("renders every frame row at the assigned overlay width", () => {
+		const overlay = new MoveOverlay(cwd, () => {});
+		const lines = overlay.render(72);
+		const plainLines = lines.map(stripAnsi);
+
+		expect(lines.map(line => visibleWidth(line))).toEqual(Array(lines.length).fill(72));
+		expect(plainLines[0]!.endsWith(uiTheme.boxRound.topRight)).toBe(true);
+		expect(plainLines.at(-1)!.endsWith(uiTheme.boxRound.bottomRight)).toBe(true);
+		for (const line of plainLines.slice(1, -1)) {
+			expect(line.endsWith(uiTheme.boxRound.vertical)).toBe(true);
+		}
+	});
+
 	it("lists child directories (excluding hidden and files) on empty input", () => {
 		const overlay = new MoveOverlay(cwd, () => {});
 		const text = strip(overlay.render(80));

package/src/modes/components/advisor-config.ts

@@ -82,9 +82,9 @@ function previewLine(text: string | undefined): string {
 	return first.length > PREVIEW_WIDTH ? `${first.slice(0, PREVIEW_WIDTH - 1)}…` : first;
 }
 
-/** Default when the set is empty or exactly read/grep/glob; else the available-ordered subset. */
+/** Omitted means default read/grep/glob; an explicit empty set means no tools. */
 function commitTools(selected: ReadonlySet<string>, all: readonly string[]): string[] | undefined {
-	if (selected.size === 0) return undefined;
+	if (selected.size === 0) return [];
 	if (selected.size === ADVISOR_DEFAULT_TOOL_NAMES.size) {
 		let matchesDefault = true;
 		for (const name of ADVISOR_DEFAULT_TOOL_NAMES) {
@@ -98,6 +98,11 @@ function commitTools(selected: ReadonlySet<string>, all: readonly string[]): str
 	return all.filter(name => selected.has(name));
 }
 
+function formatAdvisorTools(tools: readonly string[] | undefined, emptyLabel: string): string {
+	if (tools === undefined) return "read, grep, glob (default)";
+	return tools.length > 0 ? tools.join(", ") : emptyLabel;
+}
+
 /** Soft-wrap plain text to `width`, returning at least one (possibly empty) line. */
 function wrap(text: string, width: number): string[] {
 	if (!text) return [""];
@@ -266,7 +271,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 
 	#advisorPreview(advisor: AdvisorConfig, bodyWidth: number): string[] {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
-		const tools = advisor.tools?.length ? advisor.tools.join(", ") : "read, grep, glob (default)";
+		const tools = formatAdvisorTools(advisor.tools, "no tools");
 		const lines = [
 			theme.bold(advisor.name || "(unnamed)"),
 			"",
@@ -303,13 +308,16 @@ export class AdvisorConfigOverlayComponent implements Component {
 		const advisor = doc.advisors[0];
 		if (!advisor) return false;
 		return (
-			advisor.name === "default" && !advisor.model?.trim() && !advisor.tools?.length && !advisor.instructions?.trim()
+			advisor.name === "default" &&
+			!advisor.model?.trim() &&
+			advisor.tools === undefined &&
+			!advisor.instructions?.trim()
 		);
 	}
 
 	#advisorSummary(advisor: AdvisorConfig): string {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
-		const tools = advisor.tools?.length ? advisor.tools.join(", ") : "(default: read/grep/glob)";
+		const tools = formatAdvisorTools(advisor.tools, "no tools");
 		return `${model} · ${tools}`;
 	}
 
@@ -384,7 +392,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 			return;
 		}
 		const modelDescription = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
-		const toolsDescription = advisor.tools?.length ? advisor.tools.join(", ") : "(default: read/grep/glob)";
+		const toolsDescription = formatAdvisorTools(advisor.tools, "no tools");
 		const items: SelectItem[] = [
 			{ value: "name", label: "Name", description: advisor.name },
 			{ value: "model", label: "Model", description: modelDescription },
@@ -524,7 +532,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 		this.#setScreen(
 			"tools",
 			list,
-			"Enter / click toggle · select Done or Esc to apply (empty or read/grep/glob = default)",
+			"Enter / click toggle · select Done or Esc to apply (empty = no tools; read/grep/glob = default)",
 		);
 	}
 

package/src/modes/components/move-overlay.ts

@@ -25,7 +25,6 @@ interface DirEntry {
 }
 
 const MAX_RESULTS = 15;
-const OVERLAY_WIDTH = 68;
 
 /** TTL for the directory listing cache (ms). */
 const DIR_CACHE_TTL = 500;
@@ -230,8 +229,8 @@ export class MoveOverlay implements Component, Focusable {
 		}
 	}
 
-	render(_width: number): readonly string[] {
-		const w = OVERLAY_WIDTH;
+	render(width: number): readonly string[] {
+		const w = width;
 		const lines: string[] = [];
 
 		lines.push(topBorder(w, "Move to directory"));

package/src/modes/components/status-line/component.ts

@@ -275,6 +275,7 @@ export class StatusLineComponent implements Component {
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#loopModeStatus: { enabled: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
+	#vibeModeStatus: { enabled: boolean } | null = null;
 	#collabStatus: CollabStatus | null = null;
 	#focusedAgentId: string | undefined;
 	#activeRepoCache: ActiveRepoCache | undefined;
@@ -503,6 +504,10 @@ export class StatusLineComponent implements Component {
 		this.#goalModeStatus = status ?? null;
 	}
 
+	setVibeModeStatus(status: { enabled: boolean } | undefined): void {
+		this.#vibeModeStatus = status ?? null;
+	}
+
 	setCollabStatus(status: CollabStatus | null): void {
 		this.#collabStatus = status;
 	}
@@ -1047,6 +1052,7 @@ export class StatusLineComponent implements Component {
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
+			vibeMode: this.#vibeModeStatus,
 			collab: this.#collabStatus,
 			usageStats,
 			contextPercent,

package/src/modes/components/status-line/segments.ts

@@ -213,6 +213,12 @@ const modeSegment: StatusLineSegment = {
 			return renderGoalMode(ctx, goal);
 		}
 
+		const vibe = ctx.vibeMode;
+		if (vibe?.enabled) {
+			const content = withIcon(theme.icon.agents, "Vibe");
+			return { content: theme.fg("accent", content), visible: true };
+		}
+
 		const loop = ctx.loopMode;
 		if (loop?.enabled) {
 			const content = withIcon(theme.icon.loop, "Loop");

package/src/modes/components/status-line/types.ts

@@ -67,6 +67,9 @@ export interface SegmentContext {
 		enabled: boolean;
 		paused: boolean;
 	} | null;
+	vibeMode: {
+		enabled: boolean;
+	} | null;
 	collab: CollabStatus | null;
 	// Cached values for performance (computed once per render)
 	usageStats: {

package/src/modes/controllers/command-controller.ts

@@ -47,7 +47,12 @@ import { limitMatchesActiveAccount } from "../../slash-commands/helpers/active-o
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
-import { getChangelogPath, parseChangelog } from "../../utils/changelog";
+import {
+	getChangelogPath,
+	parseChangelog,
+	RECENT_CHANGELOG_ENTRY_LIMIT,
+	renderChangelogEntries,
+} from "../../utils/changelog";
 import { copyToClipboard } from "../../utils/clipboard";
 import { openPath } from "../../utils/open";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
@@ -487,16 +492,9 @@ export class CommandController {
 	async handleChangelogCommand(showFull = false): Promise<void> {
 		const changelogPath = getChangelogPath();
 		const allEntries = await parseChangelog(changelogPath);
-		// Default to showing only the latest 3 versions unless --full is specified
-		// allEntries comes from parseChangelog with newest first, reverse to show oldest->newest
-		const entriesToShow = showFull ? allEntries : allEntries.slice(0, 3);
+		const entriesToShow = showFull ? allEntries : allEntries.slice(0, RECENT_CHANGELOG_ENTRY_LIMIT);
 		const changelogMarkdown =
-			entriesToShow.length > 0
-				? [...entriesToShow]
-						.reverse()
-						.map(e => e.content)
-						.join("\n\n")
-				: "No changelog entries found.";
+			entriesToShow.length > 0 ? renderChangelogEntries(entriesToShow).markdown : "No changelog entries found.";
 		const title = showFull ? "Full Changelog" : "Recent Changes";
 		const hint = showFull
 			? ""