@oh-my-pi/pi-coding-agent 16.2.12 → 16.3.0

package/dist/types/task/render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/thinking.d.ts

@@ -41,6 +41,8 @@ export declare function resolveThinkingLevelForModel(model: Model | undefined, l
 export declare const AUTO_THINKING: "auto";
 /** A thinking selector as configured by the user — a concrete level or `auto`. */
 export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
+/** Maps the session-level `auto` sentinel to `undefined`; concrete levels pass through. */
+export declare function concreteThinkingLevel(level: ConfiguredThinkingLevel | undefined): ThinkingLevel | undefined;
 /** Metadata used to render the `auto` selector value alongside concrete levels. */
 export interface ConfiguredThinkingLevelMetadata {
     value: ConfiguredThinkingLevel;

package/dist/types/tools/checkpoint.d.ts

@@ -9,6 +9,14 @@ export interface CheckpointState {
     /** Timestamp */
     startedAt: string;
 }
+export interface CompletedRewindState {
+    /** Report retained after a successful rewind. */
+    report: string;
+    /** Timestamp for the checkpoint that was rewound. */
+    startedAt: string;
+    /** Timestamp when the rewind completed. */
+    rewoundAt: string;
+}
 declare const checkpointSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     goal: string;
 }, {}>;

package/dist/types/tools/eval-render.d.ts

@@ -53,5 +53,6 @@ export declare const evalToolRenderer: {
     mergeCallAndResult: boolean;
     inline: boolean;
     provisionalPendingPreview: string;
+    provisionalPartialResult: boolean;
 };
 export {};

package/dist/types/tools/fetch.d.ts

@@ -8,7 +8,6 @@ import type { ToolSession } from "../sdk";
 import type { AgentStorage } from "../session/agent-storage";
 import { type OutputMeta } from "./output-meta";
 import { type LineRange } from "./path-utils";
-export declare function isReadableUrlPath(value: string): boolean;
 export interface ParsedReadUrlTarget {
     path: string;
     raw: boolean;
@@ -56,9 +55,12 @@ export interface ReadUrlToolDetails {
 }
 interface ReadUrlCacheEntry {
     artifactId?: string;
+    artifactPath?: string;
+    contentPath?: string;
     details: ReadUrlToolDetails;
     image?: FetchImagePayload;
     output: string;
+    content: string;
 }
 export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
     path: string;
@@ -67,6 +69,14 @@ export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
     ensureArtifact?: boolean;
     preferCached?: boolean;
 }): Promise<ReadUrlCacheEntry>;
+/** Materialize rendered URL body text to a local file for tools that require filesystem paths. */
+export declare function materializeReadUrlToFile(session: ToolSession, params: {
+    path: string;
+    raw?: boolean;
+}, signal?: AbortSignal): Promise<{
+    path: string;
+    details: ReadUrlToolDetails;
+}>;
 export declare function executeReadUrl(session: ToolSession, params: {
     path: string;
     raw?: boolean;

package/dist/types/tools/index.d.ts

@@ -24,7 +24,7 @@ import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-disc
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type BuiltinToolName } from "./builtin-names";
-import { type CheckpointState } from "./checkpoint";
+import { type CheckpointState, type CompletedRewindState } from "./checkpoint";
 import { type TodoPhase } from "./todo";
 export * from "../edit";
 export * from "../goals";
@@ -290,6 +290,8 @@ export interface ToolSession {
     getCheckpointState?: () => CheckpointState | undefined;
     /** Set or clear active checkpoint state. */
     setCheckpointState?: (state: CheckpointState | null) => void;
+    /** Get the most recent completed rewind, if this session just rewound a checkpoint. */
+    getLastCompletedRewind?: () => CompletedRewindState | undefined;
     /** Per-session snapshot store of file contents as last shown to the model
      *  by `read`/`search`. Used by hashline anchor-stale recovery to
      *  reconstruct the version the model authored anchors against when the

package/dist/types/tools/irc.d.ts

@@ -73,6 +73,7 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
         peek?: boolean | undefined;
     }, {}>;
     readonly strict = true;
+    readonly interruptible = true;
     readonly examples: readonly ToolExample<typeof ircSchema.infer>[];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);

package/dist/types/tools/output-meta.d.ts

@@ -157,6 +157,13 @@ export declare class OutputMetaBuilder {
 /** Create a new OutputMetaBuilder. */
 export declare function outputMeta(): OutputMetaBuilder;
 export declare function formatFullOutputReference(artifactId: string): string;
+/** Remove the trailing bash raw-output artifact footer while preserving its artifact id. */
+export declare function stripRawOutputArtifactNotice(text: string): {
+    text: string;
+    artifactId?: string;
+};
+/** Remove a trailing generated output notice when metadata is unavailable. */
+export declare function stripGeneratedOutputNotice(text: string): string;
 export declare function formatTruncationMetaNotice(truncation: TruncationMeta): string;
 /**
  * Format styled artifact reference with warning color and brackets.

package/dist/types/tools/output-schema-validator.d.ts

@@ -18,12 +18,15 @@ export interface OutputValidator {
      * Per-label validators for incremental yields (`type: ["<label>"]`). Each entry validates the
      * `data` payload of a single section against the matching top-level property's sub-schema —
      * array-typed properties (e.g. `findings`) use the items schema since each yield contributes
-     * one element, while scalar properties use the property schema directly. Unknown labels (not
-     * top-level properties) have no entry and skip per-call validation. Lets the yield tool give
-     * the model retry feedback on a section as soon as it arrives, instead of deferring every
-     * mismatch to the parent's post-mortem `schema_violation`.
+     * one element, while scalar properties use the property schema directly.
      */
     readonly validateSection: ReadonlyMap<string, (value: unknown) => JsonSchemaValidationResult>;
+    /** Whether top-level schema closure makes unknown incremental yield labels invalid. */
+    readonly rejectUnknownSections: boolean;
+    /** Finite top-level section labels declared directly by the schema. Pattern-backed labels are accepted via `isKnownSection`. */
+    readonly knownSectionLabels: readonly string[];
+    /** Whether an incremental yield label is accepted by the top-level schema declaration. */
+    isKnownSection(label: string): boolean;
 }
 export interface BuildOutputValidatorResult {
     /** Present when the schema produced a usable validator (i.e. constraining schemas). Absent for missing/unconstrained schemas. */

package/dist/types/tools/path-utils.d.ts

@@ -89,6 +89,13 @@ export declare function pathTargetsSsh(path: string): boolean;
  * side-effecting `InternalUrlRouter.resolve` in tools that need a local file.
  */
 export declare function isSshUrl(path: string): boolean;
+/**
+ * True when the read tool's URL parser (`parseReadUrlTarget` in fetch.ts) would
+ * recognize this path as a readable external URL: a strict `http(s)://`, a
+ * collapsed `http(s):/host` (Node path normalization folds `//` → `/`), or a
+ * scheme-less `www.` spelling. Keep in sync with `parseReadUrlTarget`.
+ */
+export declare function isReadableUrlPath(value: string): boolean;
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
@@ -198,6 +205,13 @@ export declare function partitionExistingPaths(items: string[], cwd: string, spl
     basePath: string;
 }): Promise<PartitionedPaths>;
 export declare function resolveReadPath(filePath: string, cwd: string): string;
+/** Local file materialized from a readable external URL for shared tool-scope resolution. */
+export interface ResolvedExternalSearchUrl {
+    /** Absolute or cwd-relative file path to search. */
+    sourcePath: string;
+    /** True when the materialized file must not mint editable anchors. */
+    immutable?: boolean;
+}
 export interface ToolScopeOptions {
     rawPaths: string[];
     cwd: string;
@@ -221,6 +235,8 @@ export interface ToolScopeOptions {
     localProtocolOptions?: LocalProtocolOptions;
     /** Calling session's loaded skills — lets skill:// resolve without process-global state. */
     skills?: readonly Skill[];
+    /** Materialize readable external URLs to local text files before scope derivation. */
+    resolveExternalUrl?: (rawPath: string) => Promise<ResolvedExternalSearchUrl | undefined>;
 }
 export interface ToolScopeResolution {
     searchPath: string;

package/dist/types/tools/render-utils.d.ts

@@ -96,12 +96,15 @@ export declare function previewWindowRows(): number;
  * (ctrl+o) uncaps it.
  *
  * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
- * nested previews stay aligned.
+ * nested previews stay aligned. `expandHint: false` drops the "ctrl+o: Expand"
+ * suffix for callers that cap even inside the expanded view (task recent
+ * output), where the hint would point the wrong way.
  */
 export declare function capPreviewLines(lines: string[], theme: Theme, options?: {
     max?: number;
     expanded?: boolean;
     prefix?: string;
+    expandHint?: boolean;
 }): string[];
 export declare function formatMeta(meta: string[], theme: Theme): string;
 export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;

package/dist/types/utils/git.d.ts

@@ -88,6 +88,7 @@ export interface PatchOptions {
     readonly cached?: boolean;
     readonly check?: boolean;
     readonly env?: Record<string, string | undefined>;
+    readonly reverse?: boolean;
     readonly threeWay?: boolean;
     readonly signal?: AbortSignal;
 }
@@ -98,10 +99,17 @@ export interface RestoreOptions {
     readonly staged?: boolean;
     readonly worktree?: boolean;
 }
+export interface FetchOptions {
+    readonly signal?: AbortSignal;
+    /** Deadline for the network transfer. Defaults to {@link GIT_NETWORK_TIMEOUT_MS}. */
+    readonly timeoutMs?: number;
+}
 export interface CloneOptions {
     readonly ref?: string;
     readonly sha?: string;
     readonly signal?: AbortSignal;
+    /** Deadline for the network transfer. Defaults to {@link GIT_NETWORK_TIMEOUT_MS}. */
+    readonly timeoutMs?: number;
 }
 interface GitHeadBase extends GitRepository {
     headContent: string;
@@ -128,11 +136,24 @@ export declare class GitCommandError extends Error {
     readonly result: GitCommandResult;
     constructor(args: readonly string[], result: GitCommandResult);
 }
+/** Default deadline for git and gh subprocesses spawned by the coding agent. */
+export declare const GIT_COMMAND_TIMEOUT_MS: number;
+/**
+ * Default deadline for git subprocesses that perform network transfers
+ * (`clone`/`fetch`). Large-repo transfers legitimately outlive
+ * {@link GIT_COMMAND_TIMEOUT_MS}, so they get a wider deadline; local plumbing
+ * commands keep the short one.
+ */
+export declare const GIT_NETWORK_TIMEOUT_MS: number;
+/** Maximum captured stdout or stderr bytes retained from git and gh subprocesses. */
+export declare const GIT_COMMAND_OUTPUT_LIMIT_BYTES: number;
 interface CommandOptions {
     readonly env?: Record<string, string | undefined>;
+    readonly maxOutputBytes?: number;
     readonly readOnly?: boolean;
     readonly signal?: AbortSignal;
     readonly stdin?: string | Uint8Array | ArrayBuffer | SharedArrayBuffer;
+    readonly timeoutMs?: number;
 }
 /**
  * Serialize an async block that mutates a git repository against other
@@ -192,8 +213,8 @@ export declare function commit(cwd: string, message: string, options?: CommitOpt
 export declare function push(cwd: string, options?: PushOptions): Promise<void>;
 /** Checkout a ref. */
 export declare function checkout(cwd: string, ref: string, signal?: AbortSignal): Promise<void>;
-/** Fetch a specific refspec from a remote. */
-export declare function fetch(cwd: string, remote: string, source: string, target: string, signal?: AbortSignal): Promise<void>;
+/** Fetch a specific refspec from a remote. Network transfer: defaults to the {@link GIT_NETWORK_TIMEOUT_MS} deadline. */
+export declare function fetch(cwd: string, remote: string, source: string, target: string, options?: FetchOptions): Promise<void>;
 /** Read a tree-ish into the index. */
 export declare function readTree(cwd: string, treeish: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<void>;
 /** Write the current index as a tree and return its object id. */
@@ -311,6 +332,28 @@ export declare const stash: {
     pop(cwd: string, options?: {
         index?: boolean;
     }): Promise<void>;
+    /**
+     * Return the working-tree patch that `stash@{0}` would apply, in a form
+     * that `git apply --check` can consume. Empty string when no stash entry
+     * exists or the stash contains no diffable working-tree changes.
+     */
+    showPatch(cwd: string): Promise<string>;
+    /** Return untracked paths stored in the top stash entry. */
+    untrackedFiles(cwd: string): Promise<string[]>;
+    /**
+     * Attempt to restore the top stash entry. On success returns `true` and
+     * git drops the stash entry. On conflict returns `false`, leaves the stash
+     * entry preserved for manual resolution, and guarantees the failed restore
+     * leaves no unmerged index entries or partially-restored untracked files.
+     *
+     * The historical raw `pop` catches the failure in a `finally` block and
+     * only logs — it leaves `.git/index` with stage 1/2/3 unmerged entries
+     * that survive indefinitely, corrupting every subsequent overlay-isolated
+     * task that reads through this repo's `.git/`. See issue #4175.
+     */
+    tryPop(cwd: string, options?: {
+        index?: boolean;
+    }): Promise<boolean>;
 };
 export declare function clone(url: string, targetDir: string, options?: CloneOptions): Promise<void>;
 export declare function restore(cwd: string, options?: RestoreOptions): Promise<void>;
@@ -328,6 +371,8 @@ export declare function reset(cwd: string, options?: {
 }): Promise<void>;
 export declare function clean(cwd: string, options?: {
     ignoredOnly?: boolean;
+    includeIgnored?: boolean;
+    literalPathspecs?: boolean;
     paths?: readonly string[];
     signal?: AbortSignal;
 }): Promise<void>;

package/dist/types/web/search/provider.d.ts

@@ -6,6 +6,13 @@ export { SearchProvider } from "./providers/base";
 export { SEARCH_PROVIDER_ORDER } from "./types";
 /** Cheap, sync metadata accessor — never triggers a provider load. */
 export declare function getSearchProviderLabel(id: SearchProviderId): string;
+/** Format one provider failure for the user-facing fallback summary. */
+export declare function formatSearchProviderFailure(error: unknown, provider: Pick<SearchProvider, "id" | "label">): string;
+/** Format the ordered provider fallback failures for terminal/tool output. */
+export declare function formatSearchProviderFailures(failures: readonly {
+    provider: Pick<SearchProvider, "id" | "label">;
+    error: unknown;
+}[]): string;
 /**
  * Resolve and cache a provider instance. First call for a given id loads the
  * underlying module; subsequent calls return the cached singleton.

package/dist/types/web/search/types.d.ts

@@ -78,7 +78,7 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
 }, {
     readonly value: "duckduckgo";
     readonly label: "DuckDuckGo";
-    readonly description: "Scrapes the DuckDuckGo HTML frontend (no API key)";
+    readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
 }];
 /** Supported web search providers (every option except `auto`). */
 export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.2.12",
+	"version": "16.3.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.2.12",
-		"@oh-my-pi/omp-stats": "16.2.12",
-		"@oh-my-pi/pi-agent-core": "16.2.12",
-		"@oh-my-pi/pi-ai": "16.2.12",
-		"@oh-my-pi/pi-catalog": "16.2.12",
-		"@oh-my-pi/pi-mnemopi": "16.2.12",
-		"@oh-my-pi/pi-natives": "16.2.12",
-		"@oh-my-pi/pi-tui": "16.2.12",
-		"@oh-my-pi/pi-utils": "16.2.12",
-		"@oh-my-pi/pi-wire": "16.2.12",
-		"@oh-my-pi/snapcompact": "16.2.12",
+		"@oh-my-pi/hashline": "16.3.0",
+		"@oh-my-pi/omp-stats": "16.3.0",
+		"@oh-my-pi/pi-agent-core": "16.3.0",
+		"@oh-my-pi/pi-ai": "16.3.0",
+		"@oh-my-pi/pi-catalog": "16.3.0",
+		"@oh-my-pi/pi-mnemopi": "16.3.0",
+		"@oh-my-pi/pi-natives": "16.3.0",
+		"@oh-my-pi/pi-tui": "16.3.0",
+		"@oh-my-pi/pi-utils": "16.3.0",
+		"@oh-my-pi/pi-wire": "16.3.0",
+		"@oh-my-pi/snapcompact": "16.3.0",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/config.ts

@@ -10,8 +10,10 @@ import { collectConfigCandidates } from "./watchdog";
 /**
  * One advisor declared in a `WATCHDOG.yml` file. `model` is a model selector
  * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
- * resolved exactly like any other model override; `tools` is a subset of the
- * read-only investigative tool names (default: all). `instructions` is the
+ * resolved exactly like any other model override; `tools` is a subset of
+ * `BUILTIN_TOOL_NAMES` — any built-in name, including mutating tools such as
+ * `edit`/`write`/`bash` (the advisor is a full agent). Omitted or empty falls
+ * back to the default `read`/`grep`/`glob` subset. `instructions` is the
  * advisor's specialization, appended to the shared baseline.
  */
 export interface AdvisorConfig {

package/src/cli/bench-cli.ts

@@ -30,7 +30,12 @@ import { buildServiceTierByFamily, serviceTierForAllFamilies, serviceTierSetting
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
-import { resolveThinkingLevelForModel, shouldDisableReasoning, toReasoningEffort } from "../thinking";
+import {
+	concreteThinkingLevel,
+	resolveThinkingLevelForModel,
+	shouldDisableReasoning,
+	toReasoningEffort,
+} from "../thinking";
 
 const DEFAULT_RUNS = 10;
 const DEFAULT_PAR = 4;
@@ -477,7 +482,7 @@ function resolveBenchModels(
 		resolved.push({
 			selector,
 			model,
-			thinking: resolveThinkingLevelForModel(model, result.thinkingLevel),
+			thinking: resolveThinkingLevelForModel(model, concreteThinkingLevel(result.thinkingLevel)),
 		});
 	}
 	if (errors.length > 0) {

package/src/collab/guest.ts

@@ -9,6 +9,9 @@
  * ecosystem is mirrored too: agent snapshots populate a local AgentRegistry
  * (Agent Hub), EventBus traffic (observer HUD) is republished, and hub
  * actions (chat/kill/revive/transcript reads) round-trip over the wire.
+ * Host ask dialogs (`ui-request` select/editor) present through the same
+ * hook selector/editor seam and answer with `ui-response`; `ui-request-end`
+ * dismisses a pending presentation without responding.
  * Everything renders through the same components, so ctrl+o, theming, and
  * transcript behavior are native by construction.
  */
@@ -16,7 +19,7 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { getConfigRootDir, logger } from "@oh-my-pi/pi-utils";
-import type { AgentHubRemote } from "../modes/components/agent-hub";
+import type { AgentHubRemote, AgentHubRemoteTranscript } from "../modes/components/agent-hub";
 import type { InteractiveModeContext } from "../modes/types";
 import { AgentRegistry } from "../registry/agent-registry";
 import type { AgentSessionEvent } from "../session/agent-session";
@@ -30,6 +33,7 @@ import {
 	COLLAB_PROTO,
 	type CollabFrame,
 	type CollabSessionState,
+	type CollabUiRequest,
 	parseCollabLink,
 } from "./protocol";
 import { CollabSocket } from "./relay-client";
@@ -155,7 +159,9 @@ export class CollabGuestLink {
 	readonly agentRegistry = new AgentRegistry();
 	/** Per-agent `hasSessionFile` from the last snapshot; gates remote transcript fetches. */
 	#agentHasTranscript = new Map<string, boolean>();
-	#pendingTranscripts = new Map<number, (r: { text: string; newSize: number } | null) => void>();
+	#pendingTranscripts = new Map<number, (r: AgentHubRemoteTranscript | null) => void>();
+	/** Host `ui-request`s presented (or queued) locally, keyed by reqId; aborting dismisses. */
+	#pendingUiRequests = new Map<number, AbortController>();
 	#nextReqId = 1;
 	readonly #hubRemote: AgentHubRemote = {
 		chat: (id, text) => {
@@ -176,7 +182,7 @@ export class CollabGuestLink {
 				return Promise.resolve(null);
 			}
 			const reqId = this.#nextReqId++;
-			const { promise, resolve } = Promise.withResolvers<{ text: string; newSize: number } | null>();
+			const { promise, resolve } = Promise.withResolvers<AgentHubRemoteTranscript | null>();
 			const timer = setTimeout(() => {
 				this.#pendingTranscripts.delete(reqId);
 				resolve(null);
@@ -269,6 +275,16 @@ export class CollabGuestLink {
 						}
 						return;
 					}
+					if (frame.t === "error" && !this.#welcomed && !this.#left) {
+						// Pre-welcome errors are the host's targeted reply to our
+						// hello (e.g. protocol mismatch): no welcome will follow.
+						// Fail the join with the host's message instead of hanging
+						// until the welcome timeout.
+						this.#clearWelcomeTimer();
+						if (joined) this.#ctx.showError(`Collab host: ${frame.message}`);
+						else firstWelcome.reject(new Error(frame.message));
+						return;
+					}
 					if (!this.#welcomed || this.#left) return;
 					this.#applyFrame(frame);
 				})
@@ -480,11 +496,17 @@ export class CollabGuestLink {
 				this.#applyAgentSnapshots(frame.agents);
 				this.#ctx.syncRunningSubagentBadge();
 				break;
+			case "ui-request":
+				this.#presentUiRequest(frame.request);
+				break;
+			case "ui-request-end":
+				this.#endUiRequest(frame.reqId);
+				break;
 			case "transcript": {
 				const resolve = this.#pendingTranscripts.get(frame.reqId);
 				if (resolve) {
 					this.#pendingTranscripts.delete(frame.reqId);
-					resolve(frame.error ? null : { text: frame.text, newSize: frame.newSize });
+					resolve({ text: frame.text, newSize: frame.newSize, error: frame.error });
 				}
 				break;
 			}
@@ -591,7 +613,74 @@ export class CollabGuestLink {
 		this.#pendingTranscripts.clear();
 	}
 
+	/**
+	 * Surface a host `ui-request` (ask select/editor) through the local
+	 * hook-dialog seam. The dialog settles on user submit/cancel — both send a
+	 * `ui-response` (cancel carries `value: undefined`, mirroring the web
+	 * client's Cancel button) — or when {@link #endUiRequest} aborts it because
+	 * the host settled the request elsewhere; that path must NOT respond.
+	 */
+	#presentUiRequest(request: CollabUiRequest): void {
+		// The host only targets writable peers; drop defensively on a read-only link.
+		if (this.#readOnly || this.#pendingUiRequests.has(request.reqId)) return;
+		const abort = new AbortController();
+		this.#pendingUiRequests.set(request.reqId, abort);
+		const dialog =
+			request.kind === "select"
+				? this.#ctx.showHookSelector(request.title, request.options, {
+						signal: abort.signal,
+						initialIndex: request.initialIndex,
+						selectionMarker: request.selectionMarker,
+						checkedIndices: request.checkedIndices,
+						markableCount: request.markableCount,
+						helpText: request.helpText,
+					})
+				: this.#ctx.showHookEditor(request.title, request.prefill, { signal: abort.signal });
+		dialog
+			.then(value => {
+				// Identity check: only the presentation that still owns the reqId
+				// may respond. An abort from #endUiRequest / #clearUiRequests
+				// removes (or replaces, on resync replay) the entry before this
+				// microtask runs, so a dismissed dialog stays silent.
+				if (this.#pendingUiRequests.get(request.reqId) !== abort) return;
+				this.#pendingUiRequests.delete(request.reqId);
+				this.#socket?.send({ t: "ui-response", reqId: request.reqId, value });
+			})
+			.catch(err => {
+				if (this.#pendingUiRequests.get(request.reqId) === abort) {
+					this.#pendingUiRequests.delete(request.reqId);
+				}
+				logger.warn("collab guest ui-request presentation failed", {
+					reqId: request.reqId,
+					error: String(err),
+				});
+			});
+	}
+
+	/** Host settled the request (answered elsewhere or aborted): dismiss without responding. */
+	#endUiRequest(reqId: number): void {
+		const abort = this.#pendingUiRequests.get(reqId);
+		if (!abort) return;
+		this.#pendingUiRequests.delete(reqId);
+		abort.abort();
+	}
+
+	/**
+	 * Dismiss every locally presented `ui-request` without responding: on
+	 * resync the host replays the ones still pending, and on leave they are no
+	 * longer ours to answer. Queued dialogs abort before the presented one
+	 * (reverse insertion order) so settling the active dialog cannot flash the
+	 * next queued one onto the surface first.
+	 */
+	#clearUiRequests(): void {
+		if (this.#pendingUiRequests.size === 0) return;
+		const aborts = [...this.#pendingUiRequests.values()];
+		this.#pendingUiRequests.clear();
+		for (const abort of aborts.reverse()) abort.abort();
+	}
+
 	#clearTransientUi(): void {
+		this.#clearUiRequests();
 		this.#ctx.statusContainer.clear();
 		this.#ctx.pendingMessagesContainer.clear();
 		this.#ctx.compactionQueuedMessages = [];
@@ -625,7 +714,7 @@ export class CollabGuestLink {
 		setSessionTerminalTitle(this.#ctx.sessionManager.getSessionName(), this.#ctx.sessionManager.getCwd());
 		this.#ctx.statusLine.invalidate();
 		this.#ctx.statusLine.resetActiveTime();
-		this.#ctx.updateEditorTopBorder();
+		this.#ctx.ui.requestRender();
 		this.#ctx.updateEditorBorderColor();
 		this.#ctx.renderInitialMessages({ clearTerminalHistory: true });
 		await this.#ctx.reloadTodos();