jeopi-cli 16.4.2 → 16.4.3

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

@@ -5,7 +5,7 @@ import { getMemoryRoot } from "../memories";
 import { AgentRegistry } from "../registry/agent-registry";
 import { buildDirectoryResource } from "./filesystem-resource";
 import { validateRelativePath } from "./skill-protocol";
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 
 const DEFAULT_MEMORY_FILE = "memory_summary.md";
 const MEMORY_NAMESPACE = "root";
@@ -27,6 +27,11 @@ export function memoryRootsFromRegistry(): string[] {
 	return roots;
 }
 
+function memoryRootsForContext(context?: ResolveContext): string[] {
+	if (context?.cwd) return [getMemoryRoot(getAgentDir(), context.cwd)];
+	return memoryRootsFromRegistry();
+}
+
 function ensureWithinRoot(targetPath: string, rootPath: string): void {
 	if (targetPath !== rootPath && !targetPath.startsWith(`${rootPath}${path.sep}`)) {
 		throw new Error("memory:// URL escapes memory root");
@@ -127,16 +132,16 @@ async function tryResolveInRoot(url: InternalUrl, memoryRoot: string): Promise<I
 /**
  * Protocol handler for memory:// URLs.
  *
- * Walks every active session's memory root. Worktree-based subagents have
- * their own root; first one containing the file wins. Parent and subagent
- * sharing a cwd see the same file regardless of order.
+ * Resolves file-backed roots against the calling session cwd when provided.
+ * Contextless callers fall back to the live-session registry for legacy
+ * cross-session lookups.
  */
 export class MemoryProtocolHandler implements ProtocolHandler {
 	readonly scheme = "memory";
 	readonly immutable = true;
 
-	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const roots = memoryRootsFromRegistry();
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const roots = memoryRootsForContext(context);
 
 		if (roots.length === 0) {
 			throw new Error(
@@ -166,8 +171,8 @@ export class MemoryProtocolHandler implements ProtocolHandler {
 		throw new Error(`Memory file not found: ${url.href}`);
 	}
 
-	async complete(): Promise<UrlCompletion[]> {
-		if (memoryRootsFromRegistry().length === 0) return [];
+	async complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]> {
+		if (memoryRootsForContext(context).length === 0) return [];
 		return [{ value: MEMORY_NAMESPACE, description: "Project memory summary" }];
 	}
 }

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/internal-urls/types.ts

@@ -107,6 +107,13 @@ export interface ResolveContext {
 	 * reject directory resources, so they never need the listing.
 	 */
 	skipDirectoryListing?: boolean;
+	/**
+	 * When set, handlers that support both a "document" and a "directory" form
+	 * for the same bare URL (e.g. `skill://name` vs `skill://name/SKILL.md`)
+	 * resolve to the directory instead of the document. Used by `glob`'s
+	 * internal-URL find path, which needs a directory to walk.
+	 */
+	pathOnly?: boolean;
 }
 
 /**

package/src/irc/bus.ts

@@ -174,7 +174,7 @@ export class IrcBus {
 		filter: { from?: string },
 		timeoutMs: number,
 		signal?: AbortSignal,
-		options?: { drainPending?: boolean },
+		options?: { drainPending?: boolean; liveness?: { registry: AgentRegistry; senderId: string } },
 	): Promise<IrcMessage | null> {
 		if (signal?.aborted) {
 			throw signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted");
@@ -189,35 +189,49 @@ export class IrcBus {
 		const { promise, resolve, reject } = Promise.withResolvers<IrcMessage | null>();
 		let timer: NodeJS.Timeout | undefined;
 		let onAbort: (() => void) | undefined;
+		let unsubscribeLiveness: (() => void) | undefined;
 
-		const waiter: IrcWaiter = {
-			from: filter.from,
-			resolve: msg => {
-				cleanup();
-				resolve(msg);
-			},
-			cancel: () => {
-				cleanup();
-			},
+		const liveness = options?.liveness;
+		const livenessReason = filter.from
+			? `IRC wait aborted: agent "${filter.from}" is not running`
+			: "IRC wait aborted: no running peers remain";
+
+		const settle = (
+			outcome: { kind: "message"; msg: IrcMessage } | { kind: "timeout" } | { kind: "abort"; error: Error },
+		): void => {
+			cleanup();
+			if (outcome.kind === "message") {
+				resolve(outcome.msg);
+			} else if (outcome.kind === "timeout") {
+				resolve(null);
+			} else {
+				reject(outcome.error);
+			}
 		};
+
 		const cleanup = (): void => {
 			this.#removeWaiter(agentId, waiter);
 			clearTimeout(timer);
 			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			unsubscribeLiveness?.();
+		};
+
+		const waiter: IrcWaiter = {
+			from: filter.from,
+			resolve: msg => settle({ kind: "message", msg }),
+			cancel: () => cleanup(),
 		};
 
 		if (signal) {
-			onAbort = () => {
-				cleanup();
-				reject(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
-			};
+			onAbort = () =>
+				settle({
+					kind: "abort",
+					error: signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"),
+				});
 			signal.addEventListener("abort", onAbort, { once: true });
 		}
 		if (timeoutMs > 0) {
-			timer = setTimeout(() => {
-				cleanup();
-				resolve(null);
-			}, timeoutMs);
+			timer = setTimeout(() => settle({ kind: "timeout" }), timeoutMs);
 			timer.unref?.();
 		}
 
@@ -227,6 +241,22 @@ export class IrcBus {
 			this.#waiters.set(agentId, waiters);
 		}
 		waiters.push(waiter);
+
+		if (liveness) {
+			const { registry, senderId } = liveness;
+			const hasRunningSender = (from?: string): boolean =>
+				registry.listVisibleTo(senderId).some(ref => ref.status === "running" && (!from || ref.id === from));
+			const check = filter.from ? () => hasRunningSender(filter.from) : () => hasRunningSender();
+			unsubscribeLiveness = registry.onChange(() => {
+				if (!check()) {
+					settle({ kind: "abort", error: new Error(livenessReason) });
+				}
+			});
+			if (!check()) {
+				settle({ kind: "abort", error: new Error(livenessReason) });
+			}
+		}
+
 		return promise;
 	}
 

package/src/lsp/client.ts

@@ -737,8 +737,14 @@ export async function getOrCreateClient(
 
 			client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
 
-			// Send initialized notification
+			// Finish the initialize handshake before publishing the client as ready.
 			await sendNotification(client, "initialized", {}, signal);
+			await sendNotification(
+				client,
+				"workspace/didChangeConfiguration",
+				{ settings: config.settings ?? {} },
+				signal,
+			);
 
 			client.status = "ready";
 			// Publish only after init succeeds: pre-init clients are reachable

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

@@ -80,9 +80,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";
@@ -641,6 +642,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;
@@ -648,18 +654,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/tool-bridge.ts

@@ -15,8 +15,10 @@ import type {
 	CustomToolResult,
 	RenderResultOptions,
 } from "../extensibility/custom-tools/types";
+import { resolveLocalUrlToFile } from "../internal-urls/local-protocol";
 import type { Theme } from "../modes/theme/theme";
 import type { OutputMeta } from "../tools/output-meta";
+import { normalizeLocalScheme } from "../tools/path-utils";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { callTool } from "./client";
 import { renderMCPCall, renderMCPResult } from "./render";
@@ -104,13 +106,62 @@ function stripHarnessIntent(args: MCPToolArgs, inputSchema: MCPToolDefinition["i
 	return rest;
 }
 
+async function resolveOutboundLocalUrlArgs(
+	value: unknown,
+	context: CustomToolContext,
+	seen: WeakSet<object> = new WeakSet(),
+): Promise<unknown> {
+	if (typeof value === "string") {
+		const normalized = normalizeLocalScheme(value);
+		if (!normalized.startsWith("local://")) return value;
+		const localFile = await resolveLocalUrlToFile(normalized, {
+			cwd: context.sessionManager?.getCwd?.(),
+			settings: context.settings,
+			localProtocolOptions: context.localProtocolOptions,
+		});
+		return localFile?.path ?? value;
+	}
+	if (typeof value !== "object" || value === null) return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+
+	if (Array.isArray(value)) {
+		let resolved: unknown[] | undefined;
+		for (let index = 0; index < value.length; index++) {
+			const item = value[index];
+			const next = await resolveOutboundLocalUrlArgs(item, context, seen);
+			if (next === item && !resolved) continue;
+			resolved ??= value.slice();
+			resolved[index] = next;
+		}
+		return resolved ?? value;
+	}
+
+	const input = value as Record<string, unknown>;
+	let resolved: Record<string, unknown> | undefined;
+	for (const key in input) {
+		const item = input[key];
+		const next = await resolveOutboundLocalUrlArgs(item, context, seen);
+		if (next === item && !resolved) continue;
+		resolved ??= { ...input };
+		resolved[key] = next;
+	}
+	return resolved ?? value;
+}
+
 /**
  * Normalize raw tool params into the outbound `tools/call` arguments: strip
- * the harness intent field, then drop optional empty placeholders the server
- * declares but doesn't require.
+ * the harness intent field, drop optional empty placeholders the server
+ * declares but doesn't require, then translate session-local files to paths
+ * external MCP servers can read.
  */
-function prepareOutboundArgs(params: unknown, inputSchema: MCPToolDefinition["inputSchema"]): MCPToolArgs {
-	return omitUnusedOptionalArgs(stripHarnessIntent(normalizeToolArgs(params), inputSchema), inputSchema);
+async function prepareOutboundArgs(
+	params: unknown,
+	inputSchema: MCPToolDefinition["inputSchema"],
+	context: CustomToolContext,
+): Promise<MCPToolArgs> {
+	const args = omitUnusedOptionalArgs(stripHarnessIntent(normalizeToolArgs(params), inputSchema), inputSchema);
+	return (await resolveOutboundLocalUrlArgs(args, context)) as MCPToolArgs;
 }
 
 /** Details included in MCP tool results for rendering */
@@ -316,7 +367,7 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		const args = prepareOutboundArgs(params, this.tool.inputSchema);
+		const args = await prepareOutboundArgs(params, this.tool.inputSchema, _ctx);
 		const provider = this.connection._source?.provider;
 		const providerName = this.connection._source?.providerName;
 
@@ -415,7 +466,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		const args = prepareOutboundArgs(params, this.tool.inputSchema);
+		const args = await prepareOutboundArgs(params, this.tool.inputSchema, _ctx);
 		const provider = this.#fallbackProvider;
 		const providerName = this.#fallbackProviderName;
 

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";
 
@@ -44,6 +44,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: {
+				JEOPI_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 !== "win32",
+					env: expect.objectContaining({
+						JEOPI_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

@@ -7,7 +7,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { type Subprocess, spawn } from "bun";
+import type { Subprocess } from "bun";
 import { getProjectDir, readJsonl, Snowflake } from "jeopi-utils";
 import { hostHasInheritableConsole } from "../../eval/py/spawn-options";
 import type {
@@ -370,8 +370,11 @@ export class StdioTransport implements MCPTransport {
 		// escape terminal job-control signals (SIGTSTP, SIGTTIN); 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` (upstream #5085).
+		this.#process = Bun.spawn(spawnCommand.cmd, {
 			cwd,
 			env,
 			stdin: "pipe",

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

@@ -128,6 +128,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`
@@ -343,12 +352,19 @@ async function elicitFromAcpClient(
 			finish(undefined);
 		});
 	const response = await promise;
-	if (response?.action !== "accept" || !response.content) {
+	if (!isAcceptedElicitation(response) || !response.content) {
 		return undefined;
 	}
 	return response.content.value;
 }
 
+/** Narrows a `CreateElicitationResponse` to the accepted-with-content branch; the SDK's `action: string` catch-all arm otherwise defeats literal narrowing on `action !== "accept"`. */
+function isAcceptedElicitation(
+	response: CreateElicitationResponse | undefined,
+): response is Extract<CreateElicitationResponse, { action: "accept" }> {
+	return response?.action === "accept";
+}
+
 /**
  * Build an {@link ExtensionUIContext} that translates skill/extension UI
  * requests into ACP elicitations against `connection` for the session
@@ -684,6 +700,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,
@@ -1197,6 +1214,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),
@@ -1204,7 +1225,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);
@@ -1212,6 +1244,7 @@ export class AcpAgent implements Agent {
 		this.#clearLiveAssistantMessageAfterEvent(record, event);
 
 		if (event.type === "agent_end") {
+			await this.#flushUnreportedTurnError(record, event);
 			await this.#emitEndOfTurnUpdates(record);
 			await this.#waitForAcpPromptIdle(record);
 			this.#finishPrompt(record, {
@@ -1221,6 +1254,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 `jeopi 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(
+			"jeopi 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: ~/.jeopi/logs/\n",
+		);
+	}
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);