@oh-my-pi/pi-coding-agent 16.3.12 → 16.3.13

package/src/mnemopi/state.ts

@@ -108,11 +108,16 @@ export interface MnemopiMemoryEditOptions {
 }
 
 export interface MnemopiMemoryEditResult {
-	status: "updated" | "deleted" | "invalidated" | "not_found";
+	status: "updated" | "deleted" | "invalidated" | "not_found" | "not_editable";
 	bank?: string;
-	store?: "working" | "episodic";
+	store?: MnemopiMemoryStore;
 }
 
+/** Which mnemopi table a resolved memory id lives in. `fact` rows are
+ * read-only projections of fact extraction (issue #4725): resolvable for
+ * reads, never editable. */
+export type MnemopiMemoryStore = "working" | "episodic" | "fact";
+
 interface MnemopiStoredMemoryRow {
 	id?: unknown;
 	content?: unknown;
@@ -136,7 +141,7 @@ interface MnemopiStoredMemoryRow {
  */
 export interface MnemopiScopedMemoryHit {
 	bank: string;
-	store: "working" | "episodic";
+	store: MnemopiMemoryStore;
 	row: {
 		id: string;
 		content: string;
@@ -256,7 +261,8 @@ export class MnemopiSessionState {
 		for (const target of targets) {
 			const raw = target.memory.get(id) as MnemopiStoredMemoryRow | null;
 			if (!raw) continue;
-			const store: MnemopiScopedMemoryHit["store"] = raw.memory_store === "episodic" ? "episodic" : "working";
+			const store: MnemopiMemoryStore =
+				raw.memory_store === "episodic" || raw.memory_store === "fact" ? raw.memory_store : "working";
 			return {
 				bank: target.bank,
 				store,
@@ -291,8 +297,16 @@ export class MnemopiSessionState {
 		for (const target of targets) {
 			const row = target.memory.get(id) as MnemopiStoredMemoryRow | null;
 			if (!row) continue;
-			const store: MnemopiMemoryEditResult["store"] = row.memory_store === "episodic" ? "episodic" : "working";
+			const store: MnemopiMemoryStore =
+				row.memory_store === "episodic" || row.memory_store === "fact" ? row.memory_store : "working";
 			const resultContext: Pick<MnemopiMemoryEditResult, "bank" | "store"> = { bank: target.bank, store };
+			if (store === "fact") {
+				// Facts are read-only: no memory_edit op mutates the facts
+				// table, so report that precisely instead of `not_found`
+				// (the id DID resolve — issue #4725).
+				ineligible ??= { status: "not_editable", ...resultContext };
+				continue;
+			}
 			if ((op === "update" || op === "forget") && store !== "working") {
 				ineligible ??= { status: "not_found", ...resultContext };
 				continue;

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

@@ -84,6 +84,7 @@ import { canonicalizeMessage } from "../../utils/thinking-display";
 import { createAcpClientBridge } from "./acp-client-bridge";
 import {
 	buildToolCallStartUpdate,
+	extractAssistantMessageText,
 	mapAgentSessionEventToAcpSessionUpdates,
 	normalizeReplayToolArguments,
 } from "./acp-event-mapper";
@@ -425,6 +426,7 @@ export function createAcpExtensionUiContext(
 		setEditorText: () => {},
 		getEditorText: () => "",
 		editor: async () => undefined,
+		addAutocompleteProvider: () => {},
 		setEditorComponent: () => {},
 		get theme() {
 			return theme;
@@ -843,13 +845,16 @@ export class AcpAgent implements Agent {
 			return false;
 		}
 		const built = await buildSkillPromptMessage(skill, parsed.args, "user");
-		await record.session.promptCustomMessage({
-			customType: SKILL_PROMPT_MESSAGE_TYPE,
-			content: built.message,
-			display: true,
-			details: built.details,
-			attribution: "user",
-		});
+		await record.session.promptCustomMessage(
+			{
+				customType: SKILL_PROMPT_MESSAGE_TYPE,
+				content: built.message,
+				display: true,
+				details: built.details,
+				attribution: "user",
+			},
+			{ streamingBehavior: "steer" },
+		);
 		return true;
 	}
 
@@ -1210,8 +1215,11 @@ export class AcpAgent implements Agent {
 		this.#clearLiveAssistantMessageAfterEvent(record, event);
 
 		if (event.type === "agent_end") {
+			await this.#flushMissedFinalAssistantText(record, event);
 			await this.#emitEndOfTurnUpdates(record);
 			await this.#waitForAcpPromptIdle(record);
+			record.liveMessageId = undefined;
+			record.liveMessageProgress = undefined;
 			this.#finishPrompt(record, {
 				stopReason: this.#resolveStopReason(event, promptTurn.cancelRequested),
 				usage: this.#buildTurnUsage(promptTurn.usageBaseline, record.session.sessionManager.getUsageStatistics()),
@@ -1219,6 +1227,51 @@ export class AcpAgent implements Agent {
 		}
 	}
 
+	/**
+	 * Deliver the final visible answer when the assistant `message_end` never
+	 * reached this prompt turn's subscription. Session event handlers are
+	 * fire-and-forget (`Agent#emit` does not await async listeners), and
+	 * `agent_end` is flushed through the session's `#endInFlight` path while the
+	 * assistant `message_end` fan-out can still be parked on extension delivery —
+	 * so `agent_end` can overtake `message_end`. Once the turn finishes,
+	 * `#finishPrompt` unsubscribes and the fallback text emission in
+	 * `mapAssistantMessageEnd` is lost for good: a client that only received
+	 * `agent_thought_chunk`s stays stuck on the thinking block (#4902). The live
+	 * message progress records whether visible text ever reached the client; if
+	 * it has not, emit the last assistant message's text before the prompt
+	 * resolves. A `message_end` that lands during the end-of-turn waits still
+	 * takes the normal mapper path and sees `textEmitted` already set, so the
+	 * answer is delivered exactly once.
+	 */
+	async #flushMissedFinalAssistantText(
+		record: ManagedSessionRecord,
+		event: Extract<AgentSessionEvent, { type: "agent_end" }>,
+	): Promise<void> {
+		const progress = record.liveMessageProgress;
+		if (!progress || progress.textEmitted) {
+			return;
+		}
+		const lastAssistant = [...event.messages]
+			.reverse()
+			.find((message): message is AssistantMessage => message.role === "assistant");
+		if (!lastAssistant) {
+			return;
+		}
+		const text = extractAssistantMessageText(lastAssistant);
+		if (text.length === 0) {
+			return;
+		}
+		progress.textEmitted = true;
+		await this.#connection.sessionUpdate({
+			sessionId: record.session.sessionId,
+			update: {
+				sessionUpdate: "agent_message_chunk",
+				content: { type: "text", text },
+				messageId: record.liveMessageId,
+			},
+		});
+	}
+
 	async #waitForAcpPromptIdle(record: ManagedSessionRecord): Promise<void> {
 		for (let pass = 0; pass < ACP_ASYNC_DELIVERY_DRAIN_MAX_PASSES; pass++) {
 			await record.session.waitForIdle();
@@ -1244,8 +1297,16 @@ export class AcpAgent implements Agent {
 		}
 	}
 
+	/**
+	 * Reset live-message tracking once the assistant `message_end` is handled.
+	 * The `agent_end` reset happens inside the `agent_end` branch of
+	 * `#handlePromptEvent` — after `#flushMissedFinalAssistantText` — so a
+	 * `message_end` that arrives during the end-of-turn waits maps against the
+	 * real progress instead of resurrecting a fresh one (which would double-emit
+	 * the final answer).
+	 */
 	#clearLiveAssistantMessageAfterEvent(record: ManagedSessionRecord, event: AgentSessionEvent): void {
-		if ((event.type === "message_end" && event.message.role === "assistant") || event.type === "agent_end") {
+		if (event.type === "message_end" && event.message.role === "assistant") {
 			record.liveMessageId = undefined;
 			record.liveMessageProgress = undefined;
 		}

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

@@ -922,7 +922,7 @@ function isTerminalOnlyDetails(value: unknown): boolean {
 	return content === undefined || (Array.isArray(content) && content.length === 0);
 }
 
-function extractAssistantMessageText(value: unknown): string {
+export function extractAssistantMessageText(value: unknown): string {
 	if (typeof value !== "object" || value === null || !("content" in value)) {
 		return "";
 	}

package/src/modes/components/read-tool-group.ts

@@ -37,6 +37,7 @@ export function readArgsTargetInternalUrl(args: unknown): boolean {
 type ReadRenderArgs = {
 	path?: string;
 	file_path?: string;
+	selector?: string;
 	// Legacy field from the old schema; tolerated for rebuilt transcripts.
 	sel?: string;
 };
@@ -344,7 +345,10 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	updateArgs(args: ReadRenderArgs, toolCallId?: string): void {
 		if (!toolCallId) return;
 		const basePath = args.file_path || args.path || "";
-		const rawPath = args.sel ? `${basePath}:${args.sel}` : basePath;
+		const rawSelector =
+			typeof args.selector === "string" ? args.selector : typeof args.sel === "string" ? args.sel : undefined;
+		const selector = rawSelector?.trim().replace(/^:+/, "");
+		const rawPath = selector && selector.length > 0 ? `${basePath}:${selector}` : basePath;
 		const entry: ReadEntry = this.#entries.get(toolCallId) ?? {
 			toolCallId,
 			path: rawPath,

package/src/modes/components/tool-execution.ts

@@ -38,7 +38,7 @@ import {
 	resolveImageOptions,
 	truncateToWidth,
 } from "../../tools/render-utils";
-import { toolRenderers } from "../../tools/renderers";
+import { type FirstResultViewportRepaint, toolRenderers } from "../../tools/renderers";
 import { TODO_STRIKE_TOTAL_FRAMES, type TodoToolDetails } from "../../tools/todo";
 import { isFramedBlockComponent, renderStatusLine, WidthAwareText } from "../../tui";
 import { sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
@@ -283,13 +283,13 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 	// history, so progress renders static gray and further partial snapshots are
 	// dropped (see #maybeFreezeBackgroundTask).
 	#backgroundTaskFrozen = false;
-	// Set on each `render()` when the last painted shape carried the streamed
-	// SSH-style placeholder / partial-result chrome. Reset gates key off these
-	// so a topology-changing update that lands before the shape reaches the
-	// terminal never triggers a full-viewport replay (which on direct terminals
-	// wipes native scrollback and flashes the user's history — reviewer note on
-	// PR #4315).
-	#placeholderShapePainted = false;
+	// Set on each `render()` when the last painted pending shape must be
+	// replayed wholesale when the first result arrives. Reset gates key off
+	// these so a topology-changing update that lands before the shape reaches
+	// the terminal never triggers a full-viewport replay (which on direct
+	// terminals wipes native scrollback and flashes the user's history —
+	// reviewer note on PR #4315).
+	#firstResultViewportRepaintShapePainted = false;
 	#partialResultShapePainted = false;
 	#renderState: {
 		spinnerFrame?: number;
@@ -497,9 +497,9 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		}
 		const hadNoResult = this.#result === undefined;
 		const wasPartialResult = this.#result !== undefined && this.#isPartial;
-		const placeholderPainted = this.#placeholderShapePainted;
+		const firstResultRepaintShapePainted = this.#firstResultViewportRepaintShapePainted;
 		const partialResultPainted = this.#partialResultShapePainted;
-		this.#placeholderShapePainted = false;
+		this.#firstResultViewportRepaintShapePainted = false;
 		this.#partialResultShapePainted = false;
 		this.#result = result;
 		this.#resultVersion++;
@@ -513,7 +513,7 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		this.#updateTodoStrikeAnimation();
 		this.#updateDisplay();
 		this.#resetDisplayForResultTopologyChange(
-			hadNoResult && placeholderPainted,
+			hadNoResult && firstResultRepaintShapePainted,
 			wasPartialResult && partialResultPainted,
 			isPartial,
 		);
@@ -810,34 +810,38 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		this.#displayBuilt = true;
 	}
 
-	#rendererFlag(name: "forceFirstResultViewportRepaint" | "forceResultViewportRepaintOnSettle"): boolean {
+	#rendererFlag(name: "forceResultViewportRepaintOnSettle"): boolean {
 		const toolValue = (this.#tool as Record<string, unknown> | undefined)?.[name];
 		const rendererValue = toolRenderers[this.#toolName]?.[name];
 		return toolValue === true || (toolValue === undefined && rendererValue === true);
 	}
 
 	/**
-	 * True while the last painted shape uses the streamed placeholder path
-	 * (`⏳ SSH: […]` / `$ …`) — the render call ran with `__partialJson` args
-	 * and no result. Kept as a per-paint fact so a topology-changing update
-	 * that lands before the placeholder reaches the terminal skips the reset.
+	 * True while the last painted pending-call shape opted into a full viewport
+	 * repaint at the first result (`forceFirstResultViewportRepaint`) — e.g. the
+	 * streamed SSH placeholder (`⏳ SSH: […]` / `$ …`) or a collapsed write tail
+	 * window, both of which the first result render re-anchors instead of
+	 * preserving. Kept as a per-paint fact so a topology-changing update that
+	 * lands before the pending rows reach the terminal skips the reset.
 	 */
-	#isPlaceholderShapeAtRender(): boolean {
+	#needsFirstResultViewportRepaintAtRender(): boolean {
 		if (this.#result !== undefined) return false;
-		if (!this.#rendererFlag("forceFirstResultViewportRepaint")) return false;
-		return partialJsonOf(this.#args) !== undefined;
+		const toolValue = (this.#tool as { forceFirstResultViewportRepaint?: FirstResultViewportRepaint } | undefined)
+			?.forceFirstResultViewportRepaint;
+		const value =
+			toolValue !== undefined ? toolValue : toolRenderers[this.#toolName]?.forceFirstResultViewportRepaint;
+		if (typeof value === "function") return value(this.#args, this.#renderState);
+		return value === true;
 	}
 
 	#resetDisplayForResultTopologyChange(
-		firstResultAfterPlaceholderPaint: boolean,
+		firstResultAfterRepaintShapePaint: boolean,
 		partialResultPaintedBeforeSettle: boolean,
 		isPartial: boolean,
 	): void {
-		const firstResultReplacesStreamedPlaceholder =
-			firstResultAfterPlaceholderPaint && this.#rendererFlag("forceFirstResultViewportRepaint");
 		const provisionalResultSettled =
 			partialResultPaintedBeforeSettle && !isPartial && this.#rendererFlag("forceResultViewportRepaintOnSettle");
-		if (firstResultReplacesStreamedPlaceholder || provisionalResultSettled) {
+		if (firstResultAfterRepaintShapePaint || provisionalResultSettled) {
 			this.#ui.resetDisplay();
 		}
 	}
@@ -848,7 +852,7 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		// override runs on every compose the parent Container performs, so a
 		// frame that never gets composed leaves the flags false and prevents a
 		// spurious `resetDisplay()`.
-		this.#placeholderShapePainted = this.#isPlaceholderShapeAtRender();
+		this.#firstResultViewportRepaintShapePainted = this.#needsFirstResultViewportRepaintAtRender();
 		this.#partialResultShapePainted = this.#result !== undefined && this.#isPartial;
 		return lines;
 	}

package/src/modes/controllers/extension-ui-controller.test.ts

@@ -8,6 +8,7 @@ import { ExtensionUiController } from "./extension-ui-controller";
 function makeHarness() {
 	const editor = new CustomEditor(getEditorTheme());
 	const requestRender = vi.fn();
+	const addAutocompleteProvider = vi.fn();
 	let uiContext: ExtensionUIContext | undefined;
 	const ctx = {
 		editor,
@@ -21,11 +22,13 @@ function makeHarness() {
 			expect(hasUI).toBe(true);
 			uiContext = context;
 		},
+		addAutocompleteProvider,
 	} as unknown as InteractiveModeContext;
 
 	return {
 		editor,
 		requestRender,
+		addAutocompleteProvider,
 		async init(): Promise<ExtensionUIContext> {
 			await new ExtensionUiController(ctx).initHooksAndCustomTools();
 			expect(uiContext).toBeDefined();
@@ -55,4 +58,17 @@ describe("ExtensionUiController editor UI", () => {
 		expect(harness.editor.getText()).toBe("hello");
 		expect(harness.requestRender).toHaveBeenCalledTimes(1);
 	});
+
+	it("bridges addAutocompleteProvider factories to the interactive mode context (#4919)", async () => {
+		const harness = makeHarness();
+		const ui = await harness.init();
+
+		expect(typeof ui.addAutocompleteProvider).toBe("function");
+
+		const factory = (current: unknown) => current as never;
+		ui.addAutocompleteProvider(factory);
+
+		expect(harness.addAutocompleteProvider).toHaveBeenCalledTimes(1);
+		expect(harness.addAutocompleteProvider).toHaveBeenCalledWith(factory);
+	});
 });

package/src/modes/controllers/extension-ui-controller.ts

@@ -82,6 +82,7 @@ export class ExtensionUiController {
 			getEditorText: () => this.ctx.editor.getText(),
 			editor: (title, prefill, dialogOptions, editorOptions) =>
 				this.showCollabAwareEditor(title, prefill, dialogOptions, editorOptions),
+			addAutocompleteProvider: factory => this.ctx.addAutocompleteProvider(factory),
 			get theme() {
 				return theme;
 			},

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

@@ -154,7 +154,6 @@ const TINY_TITLE_PROGRESS_REVEAL_DELAY_MS = 1_000;
 // deliberate human double-tap is always tens of milliseconds apart.
 const LEFT_DOUBLE_TAP_MIN_GAP_MS = 40;
 const LEFT_DOUBLE_TAP_MAX_GAP_MS = 500;
-const STREAMING_ESCAPE_CANCEL_WINDOW_MS = 2_000;
 
 export class InputController {
 	constructor(
@@ -179,16 +178,6 @@ export class InputController {
 	// (>= LEFT_DOUBLE_TAP_MAX_GAP_MS) starts a fresh sequence. See
 	// #detectLeftDoubleTap.
 	#leftTapCount = 0;
-	// Streaming turns use a two-step Esc: first press arms this token, second press
-	// within the window aborts the same live assistant turn. The token is a per-turn
-	// sentinel minted lazily on demand and reset on every `agent_start`/`agent_end`
-	// (see setupKeyHandlers), so it survives `message_start`/`message_update`
-	// transitions inside a single turn but cannot leak across turn boundaries.
-	#streamingEscapeTurnSentinel: object | undefined;
-	#streamingEscapeArmedToken: object | undefined;
-	#streamingEscapeArmedUntil = 0;
-	#streamingEscapeTimer: NodeJS.Timeout | undefined;
-	#streamingEscapeSessionSubscribed = false;
 	// Sequential index for `local://attachment-N` references created by large-paste and
 	// pasted-file attachments. Seeded from 0 and bumped past existing attachment files.
 	#attachmentCounter = 0;
@@ -238,50 +227,12 @@ export class InputController {
 		const unsubscribe = tinyTitleClient.onProgress(update);
 	}
 
-	#clearStreamingEscapeArm(): void {
-		this.#streamingEscapeArmedToken = undefined;
-		this.#streamingEscapeArmedUntil = 0;
-		if (this.#streamingEscapeTimer) {
-			clearTimeout(this.#streamingEscapeTimer);
-			this.#streamingEscapeTimer = undefined;
-		}
-	}
-
-	#handleStreamingEscape(): void {
-		if (!this.#streamingEscapeTurnSentinel) {
-			this.#streamingEscapeTurnSentinel = {};
-		}
-		const token = this.#streamingEscapeTurnSentinel;
-		const now = Date.now();
-		if (this.#streamingEscapeArmedToken === token && now <= this.#streamingEscapeArmedUntil) {
-			this.#clearStreamingEscapeArm();
-			void this.ctx.session.abort({ reason: USER_INTERRUPT_LABEL });
-			return;
-		}
-
-		this.#clearStreamingEscapeArm();
-		this.#streamingEscapeArmedToken = token;
-		this.#streamingEscapeArmedUntil = now + STREAMING_ESCAPE_CANCEL_WINDOW_MS;
-		this.#streamingEscapeTimer = setTimeout(() => {
-			if (this.#streamingEscapeArmedToken === token && Date.now() >= this.#streamingEscapeArmedUntil) {
-				this.#clearStreamingEscapeArm();
-			}
-		}, STREAMING_ESCAPE_CANCEL_WINDOW_MS);
-		this.#streamingEscapeTimer.unref?.();
-		this.ctx.showStatus("Press Esc again within 2s to cancel streaming.");
+	#abortStreamingTurn(): void {
+		void this.ctx.session.abort({ reason: USER_INTERRUPT_LABEL });
 	}
 
 	setupKeyHandlers(): void {
 		this.ctx.editor.setActionKeys("app.interrupt", this.ctx.keybindings.getKeys("app.interrupt"));
-		if (!this.#streamingEscapeSessionSubscribed && typeof this.ctx.session.subscribe === "function") {
-			this.#streamingEscapeSessionSubscribed = true;
-			this.ctx.session.subscribe(event => {
-				if (event.type === "agent_start" || event.type === "agent_end") {
-					this.#streamingEscapeTurnSentinel = undefined;
-					this.#clearStreamingEscapeArm();
-				}
-			});
-		}
 		if (!this.#focusedLeftTapListenerInstalled) {
 			this.#focusedLeftTapListenerInstalled = true;
 			this.ctx.ui.addInputListener(data => {
@@ -351,7 +302,7 @@ export class InputController {
 			if (this.ctx.loopModeEnabled) {
 				this.ctx.pauseLoop();
 				if (this.ctx.session.isStreaming) {
-					this.#handleStreamingEscape();
+					this.#abortStreamingTurn();
 				} else {
 					this.ctx.cancelPendingSubmission();
 				}
@@ -402,11 +353,10 @@ export class InputController {
 				this.ctx.isPythonMode = false;
 				this.ctx.updateEditorBorderColor();
 			} else if (this.ctx.session.isStreaming) {
-				this.#handleStreamingEscape();
+				this.#abortStreamingTurn();
 			} else if (this.ctx.editor.getText().trim()) {
-				// Esc must not destroy an in-progress draft; it only disarms a previous empty-editor Esc.
+				// Esc must not destroy an in-progress draft.
 				this.ctx.lastEscapeTime = 0;
-				this.#clearStreamingEscapeArm();
 			} else if (vocalizer.isSpeaking()) {
 				// TTS buffers seconds of PCM past the streaming abort, so an Esc
 				// arriving after the model stopped would otherwise fall through to

package/src/modes/interactive-mode.ts

@@ -16,6 +16,7 @@ import type { CompactionOutcome } from "@oh-my-pi/pi-agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, Model, Usage, UsageReport } from "@oh-my-pi/pi-ai";
 import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import type {
+	AutocompleteProvider,
 	Component,
 	EditorTheme,
 	LoaderMessageColorFn,
@@ -59,6 +60,7 @@ import { applyProviderGlobalsFromSettings } from "../config/provider-globals";
 import { isSettingsInitialized, onStatusLineSessionAccentChanged, Settings, settings } from "../config/settings";
 import { clearClaudePluginRootsCache } from "../discovery/helpers";
 import type {
+	AutocompleteProviderFactory,
 	ContextUsage,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -516,6 +518,10 @@ export class InteractiveMode implements InteractiveModeContext {
 	collabGuest?: CollabGuestLink;
 
 	#pendingSlashCommands: SlashCommand[] = [];
+	/** Built-in editor autocomplete provider, before extension wrapping. */
+	#baseAutocompleteProvider: AutocompleteProvider | undefined;
+	/** Extension-registered provider factories, applied in registration order (#4919). */
+	#autocompleteProviderFactories: AutocompleteProviderFactory[] = [];
 	#cleanupUnsubscribe?: () => void;
 	#signalTeardown?: SessionTeardown;
 	readonly #version: string;
@@ -1094,14 +1100,49 @@ export class InteractiveMode implements InteractiveModeContext {
 				// source suffix (e.g. "Review code (project)"), so pass it through verbatim.
 				description: template.description,
 			}));
-		const autocompleteProvider = this.#inputController.createAutocompleteProvider(
+		this.#baseAutocompleteProvider = this.#inputController.createAutocompleteProvider(
 			[...this.#pendingSlashCommands, ...fileSlashCommands, ...promptTemplateCommands],
 			basePath,
 		);
-		this.editor.setAutocompleteProvider(autocompleteProvider);
+		this.#applyAutocompleteProvider();
 		this.session.setSlashCommands(fileCommands);
 	}
 
+	/**
+	 * Rebuild the editor's autocomplete provider: the built-in provider wrapped
+	 * by every extension-registered factory, in registration order. A factory
+	 * that throws or returns a malformed provider is skipped so one broken
+	 * extension cannot take down core autocomplete.
+	 */
+	#applyAutocompleteProvider(): void {
+		const base = this.#baseAutocompleteProvider;
+		if (!base) return;
+		let provider = base;
+		for (const factory of this.#autocompleteProviderFactories) {
+			try {
+				const wrapped = factory(provider);
+				if (
+					wrapped &&
+					typeof wrapped.getSuggestions === "function" &&
+					typeof wrapped.applyCompletion === "function"
+				) {
+					provider = wrapped;
+				} else {
+					logger.warn("Extension autocomplete provider factory returned an invalid provider; skipping it");
+				}
+			} catch (error) {
+				logger.warn("Extension autocomplete provider factory threw; skipping it", { error: String(error) });
+			}
+		}
+		this.editor.setAutocompleteProvider(provider);
+	}
+
+	/** Stack extension autocomplete behavior on top of the built-in editor provider (#4919). */
+	addAutocompleteProvider(factory: AutocompleteProviderFactory): void {
+		this.#autocompleteProviderFactories.push(factory);
+		this.#applyAutocompleteProvider();
+	}
+
 	/**
 	 * Re-point the process and every cwd-derived cache at `newCwd` after the
 	 * active session's working directory changed (`/move` relocation or resuming

package/src/modes/rpc/rpc-client.ts

@@ -17,6 +17,7 @@ import type {
 	RpcAvailableSlashCommand,
 	RpcCommand,
 	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
 	RpcHandoffResult,
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
@@ -722,25 +723,50 @@ export class RpcClient {
 	/**
 	 * Trigger OAuth login for the given provider.
 	 * The server will emit an `open_url` extension_ui_request for the auth URL.
+	 * Providers that require pasted-code completion may then emit an `input`
+	 * extension_ui_request; pass `onManualCodeInput` to satisfy it.
 	 * Resolves when login completes or rejects on failure.
 	 *
 	 * @param onOpenUrl Called when the server emits the auth URL. The host must
-	 *   open `url` in a browser for the callback-server OAuth flow to complete.
-	 *   When the flow's callback server hosts a `/launch` redirect, `launchUrl`
-	 *   is a short loopback URL that 302s to `url` — hosts SHOULD surface it as
-	 *   the truncation-safe copy target so terminal viewport clipping cannot
-	 *   corrupt trailing OAuth query parameters (e.g. `code_challenge_method=S256`).
+	 *   open `url` in a browser. When the flow's callback server hosts a
+	 *   `/launch` redirect, `launchUrl` is a short loopback URL that 302s to
+	 *   `url` — hosts SHOULD surface it as the truncation-safe copy target so
+	 *   terminal viewport clipping cannot corrupt trailing OAuth query
+	 *   parameters (e.g. `code_challenge_method=S256`).
 	 */
 	async login(
 		providerId: string,
-		options?: { onOpenUrl?: (url: string, instructions?: string, launchUrl?: string) => void },
+		options?: {
+			onOpenUrl?: (url: string, instructions?: string, launchUrl?: string) => void;
+			onManualCodeInput?: (prompt: { title: string; placeholder?: string }) => string | Promise<string>;
+		},
 	): Promise<{ providerId: string }> {
-		const { onOpenUrl } = options ?? {};
-		const listener = onOpenUrl
-			? (req: RpcExtensionUIRequest) => {
-					if (req.method === "open_url") onOpenUrl(req.url, req.instructions, req.launchUrl);
-				}
-			: undefined;
+		const { onManualCodeInput, onOpenUrl } = options ?? {};
+		const listener =
+			onOpenUrl || onManualCodeInput
+				? (req: RpcExtensionUIRequest) => {
+						if (req.method === "open_url") {
+							onOpenUrl?.(req.url, req.instructions, req.launchUrl);
+							return;
+						}
+						if (req.method !== "input" || !onManualCodeInput) return;
+						void Promise.resolve(onManualCodeInput({ title: req.title, placeholder: req.placeholder }))
+							.then(value => {
+								this.#writeFrame({
+									type: "extension_ui_response",
+									id: req.id,
+									value,
+								});
+							})
+							.catch(() => {
+								this.#writeFrame({
+									type: "extension_ui_response",
+									id: req.id,
+									cancelled: true,
+								});
+							});
+					}
+				: undefined;
 		if (listener) this.#extensionUiListeners.add(listener);
 		try {
 			const response = await this.#send({ type: "login", providerId }, 600_000);
@@ -1006,7 +1032,10 @@ export class RpcClient {
 		}
 	}
 
-	#writeFrame(frame: RpcCommand | RpcHostToolResult | RpcHostToolUpdate, onError?: (error: Error) => void): void {
+	#writeFrame(
+		frame: RpcCommand | RpcExtensionUIResponse | RpcHostToolResult | RpcHostToolUpdate,
+		onError?: (error: Error) => void,
+	): void {
 		if (!this.#process?.stdin) {
 			throw new Error("Client not started");
 		}