@kaiserlich-dev/pi-queue-picker 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaiserlich Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# @kaiserlich-dev/pi-queue-picker
+
+A [pi](https://github.com/mariozechner/pi) extension that lets you choose between **Steer** and **Follow-up** when queuing messages while the agent is busy.
+
+## What it does
+
+By default, pressing Enter while the agent is working queues your message as a "steer" (interrupts and redirects). This extension adds an interactive picker so you can choose:
+
+- **Steer** — interrupt and redirect the agent
+- **Follow-up** — queue for after the current task finishes
+
+Queued follow-ups are **editable** in an internal buffer, so you can change mode and order before delivery.
+
+## Usage
+
+When the agent is idle, Enter submits normally. When the agent is busy:
+
+1. Type your message and press **Enter**
+2. A centered delivery popup appears with **Steer** and **Follow-up** options
+3. **Tab** or **↑↓** to switch between modes
+4. **Enter** to send with the selected mode
+5. **Escape** to cancel (restores your text)
+
+The picker remembers your last chosen mode as the default.
+
+### Editing queued messages
+
+Queued messages stay in an editable buffer until the agent finishes. To edit them:
+
+- Press **Ctrl+J** or type `/edit-queue`
+- A floating popup overlay appears showing all buffered queue items (steer + follow-up)
+- **↑↓** to navigate between messages
+- **Tab** to toggle mode (follow-up ↔ steer)
+- **j / k** to move a message up/down (reorder)
+- **e** to edit the selected message in an inline text box
+- **d** or **Delete** to remove the selected message
+- **Enter** to confirm queue changes (or save while editing)
+- **Escape** to cancel (or exit edit mode)
+
+Messages keep their selected mode and queue order when you confirm. Deleted messages are discarded.
+
+A widget above the editor shows buffered queue items:
+```
+  ⚡ Steer: also check the tests
+  📋 Follow-up: and update the docs
+  ↳ Ctrl+J queue editor · e edit · d delete · j/k move
+```
+
+### How delivery works
+
+- **Steer** messages are sent immediately (interrupt current task)
+- **Follow-up** messages are buffered and flushed one at a time when the agent finishes (`agent_end` event)
+- You can reorder items and toggle mode before they are sent
+- If you change a queued item to **Steer** in the queue editor while the agent is busy, it is injected immediately after you save
+- If the agent finishes while the picker is shown, the first queued item is flushed immediately after selection
+
+### Regression test
+
+Run the steer-injection regression test:
+
+```bash
+npm run test:regression
+```
+
+This launches pi in tmux with the local extension, reproduces the queue-edit toggle flow, and asserts that changing a queued item to **Steer** injects it immediately while the agent is still busy.
+
+## Install
+
+### npm (recommended)
+
+```bash
+pi install npm:@kaiserlich-dev/pi-queue-picker
+```
+
+### git (alternative)
+
+```bash
+pi install git:github.com/kaiserlich-dev/pi-queue-picker
+```
+
+> By default this writes to `~/.pi/agent/settings.json`. Use `-l` to install into `.pi/settings.json` for a project.
+
+Then restart pi or run `/reload`.
+
+## Compatibility
+
+Works alongside other extensions that customize the editor (e.g. `pi-powerline-footer`). Uses the `input` event API instead of replacing the editor component.
+
+### SSH / Mobile Terminals
+
+The picker is automatically disabled over SSH (detected via `SSH_TTY`/`SSH_CONNECTION`), since mobile terminal apps like Terminus can't handle the custom TUI component. Messages fall through to the default steer behavior.
+
+To manually disable the picker, set `PI_QUEUE_PICKER_DISABLE=1`.

package/extensions/buffer.ts

@@ -0,0 +1,67 @@
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import type { BufferedMessage } from "./types";
+
+/**
+ * Add a message to the buffer.
+ */
+export function addMessage(buffer: BufferedMessage[], msg: BufferedMessage): void {
+	buffer.push(msg);
+}
+
+/**
+ * Shift the next message from the front of the buffer.
+ * Used when flushing queued messages after agent finishes.
+ */
+export function shiftNext(buffer: BufferedMessage[]): BufferedMessage | undefined {
+	return buffer.shift();
+}
+
+/**
+ * Find and remove the first "steer" message from the buffer.
+ * Steer messages should interrupt immediately even while agent is busy.
+ */
+export function shiftNextSteer(buffer: BufferedMessage[]): BufferedMessage | undefined {
+	const index = buffer.findIndex((m) => m.mode === "steer");
+	if (index === -1) return undefined;
+	return buffer.splice(index, 1)[0];
+}
+
+/**
+ * Update the queue widget display.
+ * Shows a summary of buffered messages below the editor, or clears it if empty.
+ */
+export function updateWidget(ui: any, buffer: BufferedMessage[]): void {
+	if (!ui) return;
+	if (buffer.length === 0) {
+		ui.setWidget("queue-picker", undefined);
+		return;
+	}
+	ui.setWidget(
+		"queue-picker",
+		(_tui: any, theme: any) => {
+			return {
+				render: (width: number) => {
+					const safeWidth = Math.max(1, width);
+					const lines = buffer.map((msg) => {
+						const prefix =
+							msg.mode === "steer"
+								? "⚡ Steer"
+								: "📋 Follow-up";
+						return truncateToWidth(
+							theme.fg("dim", `  ${prefix}: ${msg.text}`),
+							safeWidth
+						);
+					});
+					lines.push(
+						truncateToWidth(
+							theme.fg("dim", "  ↳ Ctrl+J queue editor · e edit · d delete · j/k move"),
+							safeWidth
+						)
+					);
+					return lines;
+				},
+				invalidate() {},
+			};
+		}
+	);
+}

package/extensions/lib/render-helpers.ts

@@ -0,0 +1,52 @@
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { Theme } from "../types";
+
+export function pad(s: string, len: number): string {
+	const vis = visibleWidth(s);
+	return s + " ".repeat(Math.max(0, len - vis));
+}
+
+export function makeBox(innerW: number, theme: Theme) {
+	function row(content = ""): string {
+		const clipped = truncateToWidth(content, innerW - 1, "");
+		const vis = visibleWidth(clipped);
+		const padLen = Math.max(0, innerW - vis - 1);
+		return (
+			theme.fg("borderAccent", "│") +
+			" " +
+			clipped +
+			" ".repeat(padLen) +
+			theme.fg("borderAccent", "│")
+		);
+	}
+
+	function emptyRow(): string {
+		return (
+			theme.fg("borderAccent", "│") +
+			" ".repeat(innerW) +
+			theme.fg("borderAccent", "│")
+		);
+	}
+
+	function divider(): string {
+		return theme.fg("borderAccent", `├${"─".repeat(innerW)}┤`);
+	}
+
+	function topBorder(title: string): string {
+		const titleText = ` ${title} `;
+		const borderLen = Math.max(0, innerW - titleText.length);
+		const left = Math.floor(borderLen / 2);
+		const right = borderLen - left;
+		return (
+			theme.fg("borderAccent", `╭${"─".repeat(left)}`) +
+			theme.fg("accent", titleText) +
+			theme.fg("borderAccent", `${"─".repeat(right)}╮`)
+		);
+	}
+
+	function bottomBorder(): string {
+		return theme.fg("borderAccent", `╰${"─".repeat(innerW)}╯`);
+	}
+
+	return { row, emptyRow, divider, topBorder, bottomBorder };
+}

package/extensions/queue-picker.ts

@@ -0,0 +1,260 @@
+/**
+ * Queue Picker — choose between steering and follow-up when queuing messages.
+ *
+ * When the agent is busy and you submit a message, a picker appears:
+ *   - Tab or ↑↓ to toggle between Steer and Follow-up
+ *   - Enter to send with the selected mode
+ *   - Escape to cancel and restore your text
+ *
+ * Queued messages are held in an internal buffer so you can edit them
+ * before they're delivered. Press Ctrl+J (or /edit-queue) to open a popup:
+ *   - Toggle mode (follow-up ↔ steer)
+ *   - Reorder messages (j / k)
+ *   - Edit a queued message inline (e)
+ *   - Delete messages from the queue (d/delete)
+ *
+ * Queue items are flushed one at a time when the agent finishes.
+ *
+ * The picker remembers your last chosen mode as the default.
+ *
+ * When the agent is idle, messages submit normally.
+ *
+ * Uses the `input` event instead of a custom editor, so it's compatible
+ * with other extensions that customize the editor (e.g. pi-powerline-footer).
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { BufferedMessage, PickerMode } from "./types";
+import { nextId } from "./types";
+import { addMessage, shiftNext, shiftNextSteer, updateWidget } from "./buffer";
+import {
+	handleModePickerInput,
+	renderModePicker,
+	type ModePickerState,
+} from "./screens/mode-picker";
+import {
+	createQueueEditorState,
+	handleQueueEditorInput,
+	renderQueueEditor,
+} from "./screens/queue-editor";
+
+/** Detect limited terminals (SSH from mobile apps like Terminus) where custom TUI components crash. */
+function isLimitedTerminal(): boolean {
+	if (process.env.PI_QUEUE_PICKER_DISABLE === "1") return true;
+	if (process.env.SSH_TTY || process.env.SSH_CONNECTION) return true;
+	return false;
+}
+
+const PICKER_WIDTH = 72;
+const BOX_WIDTH = 76;
+
+export default function (pi: ExtensionAPI) {
+	let uiRef: any = null;
+	let lastMode: PickerMode = "steer";
+	let buffer: BufferedMessage[] = [];
+	let editingQueue = false;
+
+	// --- Helpers ---
+
+	function sendToPi(text: string, isIdle: boolean, mode: PickerMode) {
+		if (isIdle) {
+			pi.sendUserMessage(text);
+		} else {
+			pi.sendUserMessage(text, { deliverAs: mode });
+		}
+	}
+
+	function flushOneQueuedMessage(isIdle: boolean) {
+		const next = shiftNext(buffer);
+		if (!next) return;
+		sendToPi(next.text, isIdle, next.mode);
+		updateWidget(uiRef, buffer);
+	}
+
+	function flushOneSteerWhileBusy() {
+		const steerMsg = shiftNextSteer(buffer);
+		if (!steerMsg) return;
+		sendToPi(steerMsg.text, false, "steer");
+		updateWidget(uiRef, buffer);
+	}
+
+	function clearBuffer() {
+		buffer = [];
+		updateWidget(uiRef, buffer);
+	}
+
+	// --- Edit queue overlay popup ---
+
+	async function editQueue(ctx: any) {
+		if (buffer.length === 0) {
+			ctx.ui.notify("No queued messages", "info");
+			return;
+		}
+
+		editingQueue = true;
+
+		const editorState = createQueueEditorState(buffer);
+
+		const result: BufferedMessage[] | null = await ctx.ui.custom(
+			(
+				tui: any,
+				theme: any,
+				_kb: any,
+				done: (v: BufferedMessage[] | null) => void
+			) => {
+				return {
+					render(_width: number): string[] {
+						return renderQueueEditor(editorState, BOX_WIDTH, theme);
+					},
+					invalidate() {},
+					handleInput(data: string) {
+						const action = handleQueueEditorInput(editorState, data);
+						if (action) {
+							switch (action.type) {
+								case "save":
+									done(action.items);
+									return;
+								case "cancel":
+									done(null);
+									return;
+							}
+						}
+						tui.requestRender();
+					},
+				};
+			},
+			{
+				overlay: true,
+				overlayOptions: {
+					anchor: "center" as any,
+					width: BOX_WIDTH + 2,
+				},
+			}
+		);
+
+		editingQueue = false;
+
+		if (result === null) {
+			return;
+		}
+
+		buffer = result;
+		updateWidget(uiRef, buffer);
+
+		if (ctx.isIdle() && buffer.length > 0) {
+			flushOneQueuedMessage(true);
+		} else if (!ctx.isIdle()) {
+			flushOneSteerWhileBusy();
+		}
+	}
+
+	// --- Events ---
+
+	pi.on("session_start", (_event, ctx) => {
+		uiRef = ctx.ui;
+		clearBuffer();
+	});
+
+	pi.on("session_switch", (_event, ctx) => {
+		uiRef = ctx.ui;
+		clearBuffer();
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		if (editingQueue || buffer.length === 0) return;
+		flushOneQueuedMessage(ctx.isIdle());
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (event.source !== "interactive" || ctx.isIdle()) {
+			return { action: "continue" as const };
+		}
+
+		if (!ctx.hasUI || !event.text.trim()) {
+			return { action: "continue" as const };
+		}
+
+		if (isLimitedTerminal()) {
+			return { action: "continue" as const };
+		}
+
+		// Agent is busy — show the picker
+		const pickerState: ModePickerState = {
+			selected: lastMode,
+			messageText: event.text,
+		};
+
+		const mode = await ctx.ui.custom<PickerMode | null>(
+			(tui, theme, _kb, done) => {
+				return {
+					render(_width: number): string[] {
+						return renderModePicker(pickerState, PICKER_WIDTH, theme);
+					},
+					invalidate() {},
+					handleInput(data: string) {
+						const action = handleModePickerInput(pickerState, data);
+						if (action) {
+							switch (action.type) {
+								case "select":
+									done(action.mode);
+									return;
+								case "cancel":
+									done(null);
+									return;
+							}
+						}
+						tui.requestRender();
+					},
+				};
+			},
+			{
+				overlay: true,
+				overlayOptions: {
+					anchor: "center" as any,
+					width: PICKER_WIDTH + 2,
+				},
+			}
+		);
+
+		if (mode === null) {
+			ctx.ui.setEditorText(event.text);
+			return { action: "handled" as const };
+		}
+
+		lastMode = mode;
+
+		if (mode === "steer") {
+			pi.sendUserMessage(event.text, { deliverAs: "steer" });
+			ctx.ui.notify(`Steer: ${event.text}`, "info");
+		} else {
+			addMessage(buffer, {
+				text: event.text,
+				mode,
+				id: nextId(),
+			});
+			updateWidget(uiRef, buffer);
+			ctx.ui.notify(
+				`Queued follow-up: ${event.text}`,
+				"info"
+			);
+
+			if (ctx.isIdle()) {
+				flushOneQueuedMessage(true);
+			}
+		}
+
+		return { action: "handled" as const };
+	});
+
+	// --- Shortcut & Command ---
+
+	pi.registerShortcut("ctrl+j", {
+		description: "Edit queued messages",
+		handler: (ctx) => editQueue(ctx),
+	});
+
+	pi.registerCommand("edit-queue", {
+		description: "Edit queued messages",
+		handler: (_args, ctx) => editQueue(ctx),
+	});
+}

package/extensions/screens/mode-picker.ts

@@ -0,0 +1,92 @@
+import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import type { Theme, PickerMode, ModePickerAction } from "../types";
+import { makeBox } from "../lib/render-helpers";
+
+export interface ModePickerState {
+	selected: PickerMode;
+	messageText: string;
+}
+
+/**
+ * Handle input for the mode picker overlay.
+ * Returns an action when the user makes a selection or cancels,
+ * otherwise mutates state and returns undefined.
+ */
+export function handleModePickerInput(
+	state: ModePickerState,
+	data: string
+): ModePickerAction | undefined {
+	if (
+		matchesKey(data, "tab") ||
+		matchesKey(data, "up") ||
+		matchesKey(data, "down")
+	) {
+		state.selected = state.selected === "steer" ? "followUp" : "steer";
+		return;
+	}
+	if (matchesKey(data, "left")) {
+		state.selected = "steer";
+		return;
+	}
+	if (matchesKey(data, "right")) {
+		state.selected = "followUp";
+		return;
+	}
+	if (matchesKey(data, "return")) {
+		return { type: "select", mode: state.selected };
+	}
+	if (matchesKey(data, "escape")) {
+		return { type: "cancel" };
+	}
+	return;
+}
+
+/**
+ * Render the mode picker overlay.
+ * @param state - Current picker state
+ * @param width - Box width (rendered lines will be this wide)
+ * @param theme - Theme for styling
+ */
+export function renderModePicker(
+	state: ModePickerState,
+	width: number,
+	theme: Theme
+): string[] {
+	const innerW = width - 2;
+	const { row, emptyRow, divider, topBorder, bottomBorder } = makeBox(innerW, theme);
+
+	const lines: string[] = [];
+
+	lines.push(topBorder("Delivery"));
+	lines.push(emptyRow());
+	lines.push(row(` ${theme.bold(theme.fg("accent", "↳ Deliver queued message as"))}`));
+	lines.push(row(` ${theme.fg("muted", truncateToWidth(state.messageText, innerW - 8, "…"))}`));
+	lines.push(emptyRow());
+	lines.push(divider());
+	lines.push(emptyRow());
+
+	const steerSel = state.selected === "steer";
+	const followSel = state.selected === "followUp";
+
+	lines.push(
+		row(
+			`  ${steerSel ? theme.fg("accent", "▸") : theme.fg("dim", "·")} ${steerSel ? theme.bold(theme.fg("accent", "⚡ STEER")) : theme.bold(theme.fg("warning", "⚡ STEER"))}  ${theme.fg("dim", "Interrupt and redirect now")}`
+		)
+	);
+	lines.push(
+		row(
+			`  ${followSel ? theme.fg("accent", "▸") : theme.fg("dim", "·")} ${followSel ? theme.bold(theme.fg("accent", "📋 FOLLOW-UP")) : theme.bold(theme.fg("success", "📋 FOLLOW-UP"))}  ${theme.fg("dim", "Run after current task")}`
+		)
+	);
+
+	lines.push(emptyRow());
+	lines.push(divider());
+	lines.push(
+		row(
+			`${theme.fg("muted", "tab/↑↓")} ${theme.fg("dim", "switch")}  ${theme.fg("muted", "enter")} ${theme.fg("dim", "send")}  ${theme.fg("muted", "esc")} ${theme.fg("dim", "cancel")}`
+		)
+	);
+	lines.push(bottomBorder());
+
+	return lines;
+}

package/extensions/screens/queue-editor.ts

@@ -0,0 +1,226 @@
+import { Input, Key, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import type { Theme, BufferedMessage, QueueEditorAction } from "../types";
+import { makeBox } from "../lib/render-helpers";
+
+export interface QueueEditorState {
+	items: BufferedMessage[];
+	selected: number;
+	mode: "list" | "edit";
+	editInput: Input;
+}
+
+/**
+ * Create a new queue editor state.
+ * Clones the buffer items so edits don't affect the original until saved.
+ * Wires up the Input component's onSubmit/onEscape callbacks to manage mode transitions.
+ */
+export function createQueueEditorState(items: BufferedMessage[]): QueueEditorState {
+	const editInput = new Input();
+	const state: QueueEditorState = {
+		items: items.map((m) => ({ ...m })),
+		selected: 0,
+		mode: "list",
+		editInput,
+	};
+
+	editInput.onSubmit = (value: string) => {
+		if (state.items.length === 0) {
+			state.mode = "list";
+			return;
+		}
+		const updated = value.trim();
+		if (updated.length > 0) {
+			state.items[state.selected].text = updated;
+		}
+		state.mode = "list";
+	};
+
+	editInput.onEscape = () => {
+		state.mode = "list";
+	};
+
+	return state;
+}
+
+/**
+ * Open the inline editor for the currently selected item.
+ */
+function openEditor(state: QueueEditorState): void {
+	if (state.items.length === 0) return;
+	state.mode = "edit";
+	state.editInput.setValue(state.items[state.selected].text);
+	// Place cursor at end so appending extra context is frictionless.
+	state.editInput.handleInput("\u0005"); // Ctrl+E
+}
+
+/**
+ * Handle input for the queue editor overlay.
+ * In edit mode, delegates to the Input component.
+ * In list mode, processes navigation, reorder, toggle, delete, save, cancel.
+ * Returns an action for save/cancel, otherwise mutates state and returns undefined.
+ */
+export function handleQueueEditorInput(
+	state: QueueEditorState,
+	data: string
+): QueueEditorAction | undefined {
+	if (state.items.length === 0) {
+		if (matchesKey(data, "return") || matchesKey(data, "escape")) {
+			return { type: "save", items: [] };
+		}
+		return;
+	}
+
+	if (state.mode === "edit") {
+		state.editInput.handleInput(data);
+		return;
+	}
+
+	// --- List mode ---
+
+	const moveUp =
+		data === "k" ||
+		data === "K" ||
+		matchesKey(data, "k") ||
+		matchesKey(data, Key.shift("k")) ||
+		data === "\u001b[1;2A";
+	const moveDown =
+		data === "j" ||
+		data === "J" ||
+		matchesKey(data, "j") ||
+		matchesKey(data, Key.shift("j")) ||
+		data === "\u001b[1;2B";
+
+	if (moveUp) {
+		if (state.selected > 0) {
+			const [item] = state.items.splice(state.selected, 1);
+			state.items.splice(state.selected - 1, 0, item);
+			state.selected--;
+		}
+		return;
+	}
+	if (moveDown) {
+		if (state.selected < state.items.length - 1) {
+			const [item] = state.items.splice(state.selected, 1);
+			state.items.splice(state.selected + 1, 0, item);
+			state.selected++;
+		}
+		return;
+	}
+	if (matchesKey(data, "up")) {
+		state.selected = Math.max(0, state.selected - 1);
+		return;
+	}
+	if (matchesKey(data, "down")) {
+		state.selected = Math.min(state.items.length - 1, state.selected + 1);
+		return;
+	}
+	if (matchesKey(data, "tab")) {
+		state.items[state.selected].mode =
+			state.items[state.selected].mode === "steer" ? "followUp" : "steer";
+		return;
+	}
+	if (
+		data === "e" ||
+		data === "E" ||
+		matchesKey(data, "e") ||
+		matchesKey(data, Key.shift("e"))
+	) {
+		openEditor(state);
+		return;
+	}
+	if (
+		data === "d" ||
+		data === "D" ||
+		matchesKey(data, "delete") ||
+		matchesKey(data, "backspace")
+	) {
+		state.items.splice(state.selected, 1);
+		state.selected = Math.min(state.selected, Math.max(0, state.items.length - 1));
+		return;
+	}
+	if (matchesKey(data, "return")) {
+		return { type: "save", items: state.items };
+	}
+	if (matchesKey(data, "escape")) {
+		return { type: "cancel" };
+	}
+	return;
+}
+
+/**
+ * Render the queue editor overlay.
+ * @param state - Current editor state
+ * @param width - Box width (rendered lines will be this wide)
+ * @param theme - Theme for styling
+ */
+export function renderQueueEditor(
+	state: QueueEditorState,
+	width: number,
+	theme: Theme
+): string[] {
+	const innerW = width - 2;
+	const { row, emptyRow, divider, topBorder, bottomBorder } = makeBox(innerW, theme);
+
+	const lines: string[] = [];
+
+	lines.push(topBorder("Queue"));
+	lines.push(emptyRow());
+	lines.push(row(` ${theme.bold(theme.fg("accent", "📋 Queue Editor"))}`));
+	lines.push(row(` ${theme.fg("dim", `${state.items.length} queued ${state.items.length === 1 ? "message" : "messages"}`)}`));
+	lines.push(emptyRow());
+	lines.push(divider());
+
+	if (state.items.length === 0) {
+		lines.push(emptyRow());
+		lines.push(row(` ${theme.fg("muted", "Queue is empty")}`));
+		lines.push(emptyRow());
+	} else if (state.mode === "edit") {
+		const item = state.items[state.selected];
+		const modeTag =
+			item.mode === "steer"
+				? theme.bold(theme.fg("warning", "⚡ STEER"))
+				: theme.bold(theme.fg("success", "📋 FOLLOW-UP"));
+
+		lines.push(row(` ${theme.bold(theme.fg("accent", "✎ Edit message"))} ${theme.fg("dim", `#${state.selected + 1}`)}  ${modeTag}`));
+		lines.push(emptyRow());
+
+		for (const inputLine of state.editInput.render(Math.max(12, innerW - 4))) {
+			lines.push(row(`  ${inputLine}`));
+		}
+
+		lines.push(emptyRow());
+		lines.push(
+			row(` ${theme.fg("muted", "Enter to save · Esc to cancel · Tip: append extra context at the end")}`)
+		);
+	} else {
+		lines.push(emptyRow());
+		for (let i = 0; i < state.items.length; i++) {
+			const item = state.items[i];
+			const isSel = i === state.selected;
+			const prefix = isSel ? theme.fg("accent", "▸") : theme.fg("dim", "·");
+			const indexTag = theme.fg("dim", `${String(i + 1).padStart(2, " ")}.`);
+			const modeTag =
+				item.mode === "steer"
+					? theme.bold(theme.fg("warning", "STEER"))
+					: theme.bold(theme.fg("success", "FOLLOW"));
+			const textMaxW = Math.max(1, innerW - 25);
+			const text = truncateToWidth(item.text, textMaxW);
+			const textStyled = isSel ? theme.bold(theme.fg("accent", text)) : theme.fg("dim", text);
+
+			lines.push(row(`  ${prefix} ${indexTag} ${modeTag}  ${textStyled}`));
+		}
+		lines.push(emptyRow());
+	}
+
+	lines.push(divider());
+
+	const help =
+		state.mode === "edit"
+			? `${theme.fg("muted", "enter")} ${theme.fg("dim", "save")}  ${theme.fg("muted", "esc")} ${theme.fg("dim", "cancel edit")}`
+			: `${theme.fg("muted", "↑↓")} ${theme.fg("dim", "nav")}  ${theme.fg("muted", "j/k")} ${theme.fg("dim", "move")}  ${theme.fg("muted", "tab")} ${theme.fg("dim", "mode")}  ${theme.fg("muted", "e")} ${theme.fg("dim", "edit")}  ${theme.fg("muted", "d/del")} ${theme.fg("dim", "remove")}  ${theme.fg("muted", "enter")} ${theme.fg("dim", "save")}  ${theme.fg("muted", "esc")} ${theme.fg("dim", "close")}`;
+
+	lines.push(row(help));
+	lines.push(bottomBorder());
+
+	return lines;
+}

package/extensions/types.ts

@@ -0,0 +1,24 @@
+export type Theme = Parameters<
+	Parameters<import("@mariozechner/pi-coding-agent").ExtensionUIContext["custom"]>[0]
+>[1];
+
+export type PickerMode = "steer" | "followUp";
+
+export interface BufferedMessage {
+	text: string;
+	mode: PickerMode;
+	id: string;
+}
+
+let idCounter = 0;
+export function nextId(): string {
+	return `qp-${Date.now()}-${idCounter++}`;
+}
+
+export type ModePickerAction =
+	| { type: "select"; mode: PickerMode }
+	| { type: "cancel" };
+
+export type QueueEditorAction =
+	| { type: "save"; items: BufferedMessage[] }
+	| { type: "cancel" };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@kaiserlich-dev/pi-queue-picker",
+  "version": "1.0.0",
+  "description": "Pick between steering and follow-up when queuing messages in pi",
+  "keywords": [
+    "pi-package"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kaiserlich-dev/pi-queue-picker"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "extensions",
+    "!extensions/__tests__",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/queue-picker.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/kaiserlich-dev/pi-queue-picker/main/assets/preview.png"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  },
+  "scripts": {
+    "publish:pi": "bash ./scripts/publish.sh",
+    "test:regression": "bash ./scripts/test-regression-steer-injection.sh"
+  },
+  "devDependencies": {
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}