@oh-my-pi/pi-tui 18.2.0 → 18.2.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.2.1] - 2026-09-15
+
+### Added
+
+- `Editor.deleteCharForward()` exposes the `tui.editor.deleteCharForward` operation to hosts that resolve the chord themselves, applying the same transient-state teardown the key dispatch does (pending character jump, spelling-assist popup) and routing through Vim's `x` in Normal and Visual modes.
+
+### Changed
+
+- Inline image limits now bound Kitty graphics retained from earlier frames and fullscreen overlays; older scrollback images are evicted until replayed.
+
+### Fixed
+
+- Enter now runs a slash command whose argument completes to a directory, instead of descending into it. ([#12112](https://github.com/can1357/oh-my-pi/pull/12112) by [@Huang-404-Q](https://github.com/Huang-404-Q))
+- Fixed a resize on Windows leaving the screen with a scrolled-up duplicate transcript and no visible response to input. The in-place resize path (default-on for Warp) anchors one settled repaint on a DSR round trip, but a ConPTY host owns that grid: measured on conhost, resizing the pseudoconsole re-emits its whole viewport from `CSI H` with absolute addressing while the application writes nothing, and re-homes the cursor, so the reply reports column 1 and can never be attributed to its probe tag. ConPTY sessions now keep the alternate-screen borrow, whose settled transaction ends in the `ResizeScrollbackMode` rebuild, and skip that unattributable anchor probe — except inside a multiplexer, which answers the DSR from its own grid, and under `PI_TUI_RESIZE_IN_PLACE=1`, which restores the whole pre-change path ([#11625](https://github.com/can1357/oh-my-pi/pull/11625) by [@bse-ai](https://github.com/bse-ai)).
+- Stopped exact-width live rows from entering native scrollback during ConPTY repaints ([#9783](https://github.com/can1357/oh-my-pi/issues/9783)).
+- Forward delete no longer leaves the Vim Normal-mode cursor one column past the end of a line after deleting the final grapheme.
+- Fixed Tabby CMD sessions enabling synchronized output from a spoofed `WT_SESSION`, which caused streaming repaints to overlap when Tabby's terminal chain mishandled DEC 2026.
+- Extension command argument completions now refresh after typing a Space when the previous argument had no suggestions. ([#11060](https://github.com/can1357/oh-my-pi/issues/11060))
+- Detect the wmux Windows terminal multiplexer (`WMUX` / `WMUX_SURFACE_ID`) so its panes take the in-place viewport repaint path instead of the direct-terminal scrollback path.
+
 ## [18.2.0] - 2026-09-15
 
 ### Added

package/dist/types/autocomplete.d.ts

@@ -99,7 +99,8 @@ export declare const SKILL_NAMESPACE = "skill:";
  * popup alive through fuzzy name/description hits, so a token only matches as
  * - a prefix of the `skill:` namespace (incl. the bare `/` entry point),
  * - an explicit `skill:…` query (full fuzzy name/description search), or
- * - a prefix of the skill's bare name (`/hum` → `skill:humanizer`).
+ * - a prefix at the start of the skill bare name or one of its hyphen-delimited
+ *   segments (`/hum` → `skill:humanizer`, `/last` → `skill:research-last30days`).
  * Anything else yields no items, letting the caller fall through to path
  * completion or close the popup. Shared with the editor's accept-time
  * staleness guard so Tab/Enter never accepts a skill the refreshed popup

package/dist/types/components/editor.d.ts

@@ -228,6 +228,16 @@ export declare class Editor implements Component, Focusable {
     moveToLineEnd(): void;
     moveToMessageStart(): void;
     moveToMessageEnd(): void;
+    /** The `tui.editor.deleteCharForward` operation, callable by hosts that resolve the chord
+     *  themselves rather than redispatching the raw key (see CustomEditor's exit-chord overlap).
+     *  Mirrors the transient state the key dispatch tears down before this action so the two
+     *  cannot diverge: a pending character jump is cancelled by any other key, and an open
+     *  spelling-assist popup is dismissed by anything that is not one of its accept keys (its
+     *  debounced refresh skips assist mode, so a surviving list would hang around forever).
+     *  While Vim owns the buffer (Normal or Visual) the operation is Vim's `x` — deleting the
+     *  selection and returning to Normal in Visual mode, the grapheme under the cursor
+     *  otherwise. Only Insert mode and Vim-off editors delete straight through. */
+    deleteCharForward(): void;
     /**
      * Undo the last meaningful edit while ignoring transient text that is still present at the cursor.
      * Used for command-like autocomplete actions whose typed trigger should not count as the edit being undone.

package/dist/types/components/image.d.ts

@@ -32,6 +32,16 @@ export declare const DEFAULT_MAX_INLINE_IMAGES = 8;
  * rewritten) plus an explicit graphics purge of the demoted ids. {@link Image}
  * reports display order via {@link observe}; when that reveals a stricter split,
  * the TUI repeats the pass before emitting its terminal frame.
+ * Retired frames no longer observe their images, so the resident store is also
+ * bounded across passes. Evicting retired graphics removes their scrollback
+ * placements; a later replay can render or demote those images again.
+ *
+ * `cap` bounds one surface's live images, not the terminal's whole store. A
+ * fullscreen overlay's frame and the normal screen standing behind it are both
+ * on the terminal, and neither may delete the other's graphics — see
+ * {@link limitResidentImages} — so while a modal is up the store legitimately
+ * holds up to `cap` per surface. Read `cap` as "how many images one frame shows
+ * as graphics", not as a hard residency ceiling.
  *
  * `cap <= 0` disables budgeting: every image stays a live graphic.
  */
@@ -48,22 +58,40 @@ export declare class ImageBudget {
      * gets a fresh id every call.
      */
     acquireId(key?: string): number;
+    /**
+     * Start an alternate-buffer lifecycle. Call once per `?1049h`, before the
+     * first pass of the fullscreen overlay or resize borrow that owns the buffer.
+     *
+     * The alt split is a claim about the frame standing on that surface, and
+     * `?1049h` hands over a cleared one: the previous occupant's threshold would
+     * suppress this buffer's leading images against a frame that no longer
+     * exists, painting them as text until a corrective render lands. Passes
+     * *within* one lifecycle must keep sharing the split — that is what lets an
+     * over-cap discovery pass converge before the frame is emitted.
+     */
+    beginAltScreenLifecycle(): void;
     /**
      * Begin a render pass. Called by the renderer before composing the frame.
      * Pass `stable: true` for a partial/throwaway pass that does not walk the
      * whole tree in display order (the resize viewport fast path): {@link observe}
      * then replays the last committed per-id decision instead of one derived from
      * call order, and the pass must NOT be closed with {@link endPass}.
+     *
+     * Pass `altScreen: true` when the frame is painted on the alternate buffer
+     * (fullscreen overlay, resize borrow). The pass then reads and writes that
+     * surface's own {@link SurfaceSplit} and its live set adds to the recorded
+     * normal-screen one instead of replacing it, so a modal's threshold never
+     * reaches the transcript standing behind it.
      */
-    beginPass(stable?: boolean): void;
+    beginPass(stable?: boolean, altScreen?: boolean): void;
     /**
      * Record an image in display order and report whether it must render its text
      * fallback this frame. Called by every {@link Image} during render — including
      * on a cache hit, so the image keeps its display-order slot.
      *
      * During a `stable` pass ({@link beginPass}) the call order and visible subset
-     * are not authoritative, so the decision is the committed on-terminal split
-     * (`#suppressedIds`) keyed by id — order- and partiality-independent.
+     * are not authoritative, so the decision is the surface's committed
+     * on-terminal split, keyed by id — order- and partiality-independent.
      */
     observe(imageId: number): boolean;
     /**
@@ -71,6 +99,20 @@ export declare class ImageBudget {
      * and must be repeated before its terminal frame is emitted.
      */
     endPass(): boolean;
+    /**
+     * Bound the terminal's image store to `cap`. Demotion ({@link endPass}) already
+     * retires the graphics this frame replaced with text; this sweeps the ones no
+     * frame shows any more — images the pass simply stopped observing.
+     *
+     * Also records what this frame leaves standing on its surface, which is how
+     * the next pass on the *other* surface knows what it may not destroy.
+     */
+    limitResidentImages(): void;
+    /**
+     * Image ids a destructive reset must delete explicitly, alongside its `d=A`.
+     * Emit only from that reset's repaint; clears the queue.
+     */
+    takeResetPurgeIds(): readonly number[];
     /** Image ids to delete from the terminal this frame; clears the pending set. */
     takePurgeIds(): readonly number[];
     /** All image ids believed to be loaded in the terminal store; clears tracking. */
@@ -135,10 +177,10 @@ export declare class ImageBudget {
     /** Whether a frame has image data queued but not yet written to the terminal. */
     hasPendingTransmits(): boolean;
     /**
-     * True when the budget has nothing in flight: no live images observed on
-     * the last pass, no queued transmits, no pending purges, and no stricter
-     * threshold left to apply. A component-scoped frame may skip the observe
-     * pass only then — a partial tree walk would under-count display order.
+     * True when the budget has nothing in flight on either surface: no live images
+     * observed on the last pass, no queued transmits, no pending purges, and no
+     * stricter threshold left to apply. A component-scoped frame may skip the
+     * observe pass only then — a partial tree walk would under-count display order.
      */
     get quiescent(): boolean;
     /** Transmit sequences to write before this frame's placements; clears the queue. */

package/dist/types/terminal-capabilities.d.ts

@@ -125,6 +125,22 @@ export declare function shouldEnableSynchronizedOutputByDefault(env?: NodeJS.Pro
  * `PI_NO_DECCARA` kill switch. Pure helper for tests and `TERMINAL` construction.
  */
 export declare function detectRectangularSgrSupport(terminalId: TerminalId, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Whether the terminal implements colon-subparameter SGR styled underlines —
+ * `CSI 4 : 3 m` (curly) plus `CSI 58` / `CSI 59` underline color — as opposed to
+ * only the legacy `CSI 4 m` / `CSI 24 m` on/off underline.
+ *
+ * This is an underline-style capability, not a color depth, so it is keyed on
+ * the detected terminal, never on `TERM`/`COLORTERM`. kitty, Ghostty, WezTerm,
+ * and iTerm2 (>= 3.5) implement the full pair. Apple Terminal does NOT: it
+ * renders `CSI 4 : 0 m` (the reset half) as a solid black background that
+ * persists to end of line, and ignores SGR 58/59 — so it, along with every
+ * other unproven terminal, gets the flat underline instead. Disabled under any
+ * multiplexer: GNU screen and older tmux drop colon-form SGR, and the outer
+ * terminal's id leaks into the session env, so a proven id is not proof the
+ * bytes survive — the same reason DECCARA and synchronized output gate on it.
+ */
+export declare function detectStyledUnderlineSupport(terminalId: TerminalId, env?: NodeJS.ProcessEnv): boolean;
 /**
  * Resolve an explicit user override for OSC 8 hyperlinks. Returns `false` for
  * an opt-out, `true` for a force-on, or `null` when the user has expressed no
@@ -197,6 +213,8 @@ export interface RuntimeTerminal extends TerminalInfo {
     supportsScreenToScrollback: boolean;
     /** Whether OSC 66 text sizing is currently enabled. */
     textSizing: boolean;
+    /** Whether the terminal implements colon-subparameter styled underlines (curly + colored). */
+    styledUnderlines: boolean;
 }
 export declare const TERMINAL: RuntimeTerminal;
 /**

package/dist/types/terminal-multiplexer.d.ts

@@ -1,4 +1,20 @@
 /** True when this process is running inside a Herdr pane. */
 export declare function isInsideHerdr(env?: NodeJS.ProcessEnv): boolean;
-/** Detect whether a terminal multiplexer owns the current screen grid. */
+/** Terminal multiplexers omp recognizes as owning the screen grid. */
+export type TerminalMultiplexer = "herdr" | "tmux" | "screen" | "zellij" | "cmux" | "wmux";
+/**
+ * Classify which terminal multiplexer owns the current screen grid, or `null`
+ * for a direct terminal. Single source of truth for both the render-path gate
+ * (`isInsideTerminalMultiplexer`) and the debug snapshot label.
+ *
+ * TMUX/STY/ZELLIJ, Herdr, and the CMUX/WMUX workspace/surface/remote-transport
+ * markers are authoritative session signals. TERM can also survive when those
+ * are stripped (`sudo` without -E, `su`, env-sanitizing launchers/ssh). Do not
+ * use CMUX_SOCKET_PATH / WMUX_CLI / WMUX_PIPE here: they are CLI socket/path
+ * overrides and can be set outside a CMUX/WMUX terminal. wmux is a Windows
+ * multiplexer (Electron + xterm.js) modeled on cmux/herdr that repaints its
+ * pane in place and exports WMUX=1 plus a native WMUX_SURFACE_ID.
+ */
+export declare function classifyTerminalMultiplexer(env?: NodeJS.ProcessEnv): TerminalMultiplexer | null;
+/** True when a terminal multiplexer owns the current screen grid. */
 export declare function isInsideTerminalMultiplexer(env?: NodeJS.ProcessEnv): boolean;

package/dist/types/terminal.d.ts

@@ -142,6 +142,19 @@ export interface Terminal {
      * built against older pi-tui versions keep working.
      */
     readonly pendingOutputBytes?: number;
+    /**
+     * Whether a pseudoconsole host owns the grid this terminal writes to, so
+     * neither the cursor nor the painted rows survive a resize under the
+     * application's own model. Measured on Windows conhost: resizing the
+     * pseudoconsole makes it re-emit its whole viewport from `CSI H` with
+     * absolute addressing while the application writes nothing, and it re-homes
+     * the cursor, so a DSR reply after a resize reports column 1 instead of the
+     * column the application parked. The renderer's resize anchor recovery needs
+     * both properties, so it takes the rebuild path instead when this is set.
+     * Optional so custom Terminals built against older pi-tui versions keep
+     * working; absent means the terminal itself owns the grid.
+     */
+    readonly hostOwnsGridOnResize?: boolean;
     get kittyProtocolActive(): boolean;
     get kittyEnableSequence(): string | null;
     readonly keyboardEnhancementEnterSequence?: string | null;
@@ -209,8 +222,9 @@ export declare function isConPTYHosted(): boolean;
 export interface ProcessTerminalOptions {
     /**
      * Force ConPTY-hosted behavior on or off. Defaults to live detection via
-     * {@link isConPTYHosted}. Tests set this so the kitty-flag and write-chunking
-     * paths stay hermetic regardless of the ambient WSL env (`WSL_DISTRO_NAME` /
+     * {@link isConPTYHosted}. Tests set this so the kitty-flag, write-chunking
+     * and resize-routing ({@link Terminal.hostOwnsGridOnResize}) paths stay
+     * hermetic regardless of the ambient WSL env (`WSL_DISTRO_NAME` /
      * `WSL_INTEROP`) — the suite must behave identically on WSL and on CI.
      */
     conpty?: boolean;
@@ -247,6 +261,7 @@ export declare class ProcessTerminal implements Terminal {
     write(data: string): void;
     get columns(): number;
     get pendingOutputBytes(): number;
+    get hostOwnsGridOnResize(): boolean;
     get rows(): number;
     moveBy(lines: number): void;
     hideCursor(force?: boolean): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.2.0",
+	"version": "18.2.1",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,8 +37,8 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.2.0",
-		"@oh-my-pi/pi-utils": "18.2.0"
+		"@oh-my-pi/pi-natives": "18.2.1",
+		"@oh-my-pi/pi-utils": "18.2.1"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/autocomplete.ts

@@ -351,7 +351,7 @@ function buildSlashCommandCompletions(
 						: isSkillCommand
 							? Math.max(
 									scoreCommandTextMatch(lowerPrefix, name.toLowerCase()),
-									scoreCommandTextMatch(lowerPrefix, name.slice(SKILL_NAMESPACE.length).toLowerCase()),
+									skillBareNameBreakoutTier(lowerPrefix, name.slice(SKILL_NAMESPACE.length).toLowerCase()),
 								)
 							: scoreCommandTextMatch(lowerPrefix, name.toLowerCase());
 				const lowerDesc = staticDesc.toLowerCase();
@@ -410,29 +410,54 @@ function hasPromptTextBeforeSlash(
 
 export const SKILL_NAMESPACE = "skill:";
 
-/**
- * Match tier used to compare a skill's bare name against non-skill command
- * names when deciding whether the skill may break out of the collapsed
- * `skill:` group: exact (1000) > prefix (900) > anything weaker (0). Fuzzy
- * hits deliberately map to 0 — a fuzzy skill match is never strong enough to
- * mix skills into the command popup.
- */
-function skillBreakoutTier(lowerPrefix: string, lowerTarget: string): number {
+/** Exact/leading-prefix tier for ordinary command names and aliases. */
+function commandBreakoutTier(lowerPrefix: string, lowerTarget: string): number {
 	if (lowerPrefix === lowerTarget) return 1000;
 	if (lowerTarget.startsWith(lowerPrefix)) return 900;
 	return 0;
 }
 
+/**
+ * Match a bare skill name from the beginning of any hyphen-delimited segment.
+ * This stays allocation-free on the hot path: it scans segment boundaries
+ * in-place and never materializes split/slice arrays.
+ */
+function skillBareNameBreakoutTier(lowerPrefix: string, lowerBareName: string): number {
+	if (lowerPrefix.length === 0) return 0;
+	if (lowerPrefix === lowerBareName) return 1000;
+	if (lowerBareName.startsWith(lowerPrefix)) return 900;
+
+	let segmentStart = 0;
+	while (segmentStart < lowerBareName.length) {
+		while (segmentStart < lowerBareName.length && lowerBareName.charCodeAt(segmentStart) !== 45) {
+			segmentStart += 1;
+		}
+		segmentStart += 1;
+		if (segmentStart >= lowerBareName.length) break;
+
+		if (lowerBareName.startsWith(lowerPrefix, segmentStart)) {
+			let segmentEnd = segmentStart;
+			while (segmentEnd < lowerBareName.length && lowerBareName.charCodeAt(segmentEnd) !== 45) {
+				segmentEnd += 1;
+			}
+			return lowerPrefix.length === segmentEnd - segmentStart ? 1000 : 900;
+		}
+	}
+
+	return 0;
+}
+
 /**
  * Collapse `skill:*` commands into a single `/skill:` namespace row while the
  * typed prefix has not committed to the namespace. A lone group entry (shown
  * only while the prefix is still a prefix of `skill:`) keeps the `/` popup
  * readable. A skill breaks out of the group only when its bare name matches
- * the prefix at a strictly stronger tier than every non-skill command name
- * and alias (`/batch` → `skill:batch` while no command prefix-matches
- * `batch`); a tie keeps the popup command-only, and fuzzy-only skill hits
- * never surface. Accepting the group inserts `/skill:` without a trailing
- * space so the reopened popup expands to the individual skills.
+ * the prefix at the beginning of the name or a hyphen-delimited segment, at a
+ * strictly stronger tier than every non-skill command name and alias. Ordinary
+ * commands keep exact/leading-prefix tiers only; a tie keeps the popup
+ * command-only, and fuzzy-only skill hits never surface. Accepting the group
+ * inserts `/skill:` without a trailing space so the reopened popup expands to
+ * the individual skills.
  */
 function collapseSkillNamespace(commands: CommandEntry[], lowerPrefix: string): CommandEntry[] {
 	if (lowerPrefix.startsWith(SKILL_NAMESPACE)) return commands;
@@ -442,9 +467,9 @@ function collapseSkillNamespace(commands: CommandEntry[], lowerPrefix: string):
 		for (const cmd of commands) {
 			const name = getCommandName(cmd);
 			if (!name || name.startsWith(SKILL_NAMESPACE)) continue;
-			commandTier = Math.max(commandTier, skillBreakoutTier(lowerPrefix, name.toLowerCase()));
+			commandTier = Math.max(commandTier, commandBreakoutTier(lowerPrefix, name.toLowerCase()));
 			for (const alias of getCommandAliases(cmd)) {
-				commandTier = Math.max(commandTier, skillBreakoutTier(lowerPrefix, alias.toLowerCase()));
+				commandTier = Math.max(commandTier, commandBreakoutTier(lowerPrefix, alias.toLowerCase()));
 			}
 			if (commandTier === 1000) break;
 		}
@@ -458,7 +483,7 @@ function collapseSkillNamespace(commands: CommandEntry[], lowerPrefix: string):
 		skillIcon ??= cmd.icon;
 		return (
 			!approachesNamespace &&
-			skillBreakoutTier(lowerPrefix, name.slice(SKILL_NAMESPACE.length).toLowerCase()) > commandTier
+			skillBareNameBreakoutTier(lowerPrefix, name.slice(SKILL_NAMESPACE.length).toLowerCase()) > commandTier
 		);
 	});
 	if (skillCount === 0) return commands;
@@ -478,7 +503,8 @@ function collapseSkillNamespace(commands: CommandEntry[], lowerPrefix: string):
  * popup alive through fuzzy name/description hits, so a token only matches as
  * - a prefix of the `skill:` namespace (incl. the bare `/` entry point),
  * - an explicit `skill:…` query (full fuzzy name/description search), or
- * - a prefix of the skill's bare name (`/hum` → `skill:humanizer`).
+ * - a prefix at the start of the skill bare name or one of its hyphen-delimited
+ *   segments (`/hum` → `skill:humanizer`, `/last` → `skill:research-last30days`).
  * Anything else yields no items, letting the caller fall through to path
  * completion or close the popup. Shared with the editor's accept-time
  * staleness guard so Tab/Enter never accepts a skill the refreshed popup
@@ -491,7 +517,10 @@ export function midPromptSkillTokenMatches(lowerToken: string, name: string, des
 		if (scoreCommandTextMatch(lowerToken, lowerName) > 0) return true;
 		return !!description && scoreCommandTextMatch(lowerToken, description.toLowerCase()) > 0;
 	}
-	return lowerName.startsWith(SKILL_NAMESPACE) && lowerName.slice(SKILL_NAMESPACE.length).startsWith(lowerToken);
+	return (
+		lowerName.startsWith(SKILL_NAMESPACE) &&
+		skillBareNameBreakoutTier(lowerToken, lowerName.slice(SKILL_NAMESPACE.length)) > 0
+	);
 }
 
 function buildMidPromptSkillCompletions(commands: CommandEntry[], lowerPrefix: string): AutocompleteItem[] {

package/src/components/editor.ts

@@ -1719,7 +1719,14 @@ export class Editor implements Component, Focusable {
 					} else {
 						if (selected && this.#autocompleteProvider) {
 							const shouldChainSlashCommandAutocomplete = this.#isSlashCommandNameAutocompleteSelection();
-							const shouldChainDirectoryCompletion = isDirectoryCompletionValue(selected.value);
+							// Directory chaining exists so an @ mention can be browsed deeper
+							// without retyping the path. It must not apply to a slash
+							// command's directory argument: there the accepted value is the
+							// whole argument, so chaining reopens the popup on the directory's
+							// children, the command never submits, and every further Enter
+							// descends another level (#12107).
+							const shouldChainDirectoryCompletion =
+								this.#autocompletePrefix.startsWith("@") && isDirectoryCompletionValue(selected.value);
 							const result = this.#autocompleteProvider.applyCompletion(
 								this.#state.lines,
 								this.#state.cursorLine,
@@ -2498,6 +2505,29 @@ export class Editor implements Component, Focusable {
 		this.#moveToMessageEnd();
 	}
 
+	/** The `tui.editor.deleteCharForward` operation, callable by hosts that resolve the chord
+	 *  themselves rather than redispatching the raw key (see CustomEditor's exit-chord overlap).
+	 *  Mirrors the transient state the key dispatch tears down before this action so the two
+	 *  cannot diverge: a pending character jump is cancelled by any other key, and an open
+	 *  spelling-assist popup is dismissed by anything that is not one of its accept keys (its
+	 *  debounced refresh skips assist mode, so a surviving list would hang around forever).
+	 *  While Vim owns the buffer (Normal or Visual) the operation is Vim's `x` — deleting the
+	 *  selection and returning to Normal in Visual mode, the grapheme under the cursor
+	 *  otherwise. Only Insert mode and Vim-off editors delete straight through. */
+	deleteCharForward(): void {
+		this.#jumpMode = null;
+		if (this.#autocompleteState === "assist") {
+			this.#cancelAutocomplete();
+			this.onAutocompleteUpdate?.();
+		}
+		const vim = this.#vim;
+		if (vim !== null && vim.mode !== "insert") {
+			this.#runVimKey("x", vim);
+			return;
+		}
+		this.#handleForwardDelete();
+	}
+
 	/**
 	 * Undo the last meaningful edit while ignoring transient text that is still present at the cursor.
 	 * Used for command-like autocomplete actions whose typed trigger should not count as the edit being undone.
@@ -2761,6 +2791,10 @@ export class Editor implements Component, Focusable {
 			else if (char === "#") {
 				this.#tryTriggerAutocomplete();
 			}
+			// Argument providers may expose candidates only after a separator.
+			else if (char === " " && this.#isInSubmittedSlashCommandContext()) {
+				this.#tryTriggerAutocomplete();
+			}
 			// Also auto-trigger when typing letters/path chars in a completable context
 			else if (/[a-zA-Z0-9.\-_/]/.test(char)) {
 				const currentLine = this.#state.lines[this.#state.cursorLine] || "";
@@ -3543,6 +3577,13 @@ export class Editor implements Component, Focusable {
 			this.#state.lines.splice(this.#state.cursorLine + 1, 1);
 		}
 
+		// Deleting the final grapheme can leave the cursor one past the end of the line, which
+		// Normal mode never allows (it rests *on* a grapheme). Vim's own `x` clamps via
+		// #applyVimCommands; callers that invoke this operation directly — hosts resolving a
+		// chord themselves, or a key bound to deleteCharForward that Vim does not map — get the
+		// same treatment here so the cursor can't sit off the buffer.
+		this.#clampVimCursor();
+
 		this.#notifyChange();
 
 		// Update or re-trigger autocomplete after forward delete