feat: type-ahead queue, expanded verbs, VS Code tab title

- Mid-turn typing: pressing Enter while the agent is busy now queues the
  prompt instead of dropping it. Drains automatically (one at a time, in
  order) the moment the agent goes idle. Status pane shows "↩ queued (N):
  <preview>" on enqueue. Ctrl-C while busy clears the queue along with
  aborting the turn. Slash commands and `!cmd` shell escapes still run
  immediately — they don't talk to the agent.

- THINKING_VERBS expanded from 12 to 34 engineering-themed verbs. Mix of
  standard build/compile/index/parse + dev-humor (yak-shaving,
  reticulating, hoisting, refactoring). All clearly "machine doing work."

- VS Code / Cursor terminal tabs showed "node" despite our OSC 0 write
  because their default tab-title template reads ${process} (the OS
  process name), not ${sequence}. Setting process.title alongside the
  OSC escape closes the gap — both channels updated.

Implementation note on the queue: kept it simple, single React state
array with a useEffect that drains on status === "idle". CC's queue is
priority-aware and accepts items from multiple sources (notifications,
permissions); we have one source (user input), so we don't need the
elaboration.

Author: halfaipg

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codebase-cli",
-	"version": "2.0.0-pre.49",
+	"version": "2.0.0-pre.50",
 	"description": "Codebase CLI — a TypeScript coding agent on the pi-mono runtime. OAuth-aware, any LLM provider, single install.",
 	"keywords": [
 		"ai",

src/ui/App.tsx

@@ -107,6 +107,11 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 	const [tasks, setTasks] = useState<readonly Task[]>(() => bundle.toolContext.tasks.list());
 	const inputRef = useRef<InputHandle | null>(null);
 	const [modelPickerOpen, setModelPickerOpen] = useState(false);
+	// Prompts typed while the agent is busy. The bottom of the queue is
+	// dispatched automatically when the agent goes idle. Lets the user
+	// stack the next thing while the current turn is still running, the
+	// CC-style "type ahead" pattern.
+	const [queuedPrompts, setQueuedPrompts] = useState<readonly string[]>([]);
 
 	const registry = useMemo(() => {
 		const reg = new CommandRegistry();
@@ -159,7 +164,23 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 
 	const { suggestion, dismiss: dismissSuggestion } = usePromptSuggestion(bundle, state.status, state.messages.length);
 
+	// Hold the freshest handleSubmit in a ref so the drain effect below
+	// can call into it without subscribing to every dependency change. The
+	// effect only re-runs when status or queue length flips — calling
+	// .current at fire time gives it the latest closure.
+	const handleSubmitRef = useRef<((text: string) => Promise<void>) | null>(null);
+
 	const handleSubmit = async (text: string) => {
+		// Mid-turn typing: if the agent is mid-run, queue the prompt instead
+		// of dropping or interrupting. Slash commands and `!cmd` shell
+		// escapes bypass the queue — they don't talk to the agent, so they
+		// can run alongside whatever the agent is doing.
+		if (busy && !text.startsWith("/") && !text.startsWith("!")) {
+			setQueuedPrompts((q) => [...q, text]);
+			const preview = text.length > 60 ? `${text.slice(0, 60)}…` : text;
+			appendStatus(`↩ queued (${queuedPrompts.length + 1}): ${preview}`);
+			return;
+		}
 		// `!cmd` runs a shell command directly without involving the LLM —
 		// "I just want to check something real quick." We bypass the agent
 		// loop entirely and inject the output as a synthetic user /
@@ -242,6 +263,19 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 		});
 	};
 
+	handleSubmitRef.current = handleSubmit;
+
+	// Drain queued prompts one at a time when the agent goes idle. The
+	// effect runs on every status / queue-length change, but the early
+	// return keeps the body cheap until both conditions are met.
+	useEffect(() => {
+		if (state.status !== "idle") return;
+		if (queuedPrompts.length === 0) return;
+		const [next, ...rest] = queuedPrompts;
+		setQueuedPrompts(rest);
+		void handleSubmitRef.current?.(next);
+	}, [state.status, queuedPrompts]);
+
 	// Ctrl-C semantics, in priority order:
 	//   1. Open overlay (Permission, UserQuery) → dismiss it. Never trap
 	//      the user behind a prompt with no escape.
@@ -288,6 +322,12 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 		if (busy) {
 			bundle.agent.abort();
 			dispatch({ type: "abort" });
+			// Cancel anything the user queued for after this turn — they
+			// just hit Ctrl-C, the queue is no longer what they want.
+			if (queuedPrompts.length > 0) {
+				setQueuedPrompts([]);
+				appendStatus(`(dropped ${queuedPrompts.length} queued prompt${queuedPrompts.length === 1 ? "" : "s"})`);
+			}
 			// No hint here — the abort itself is the feedback. The
 			// exit window is set silently so a quick second tap still
 			// gets the user out without confirmation theater.
@@ -402,7 +442,6 @@ function ChatApp({ initialBundle, onExit }: ChatAppProps) {
 			) : (
 				<Input
 					ref={inputRef}
-					disabled={busy}
 					onSubmit={handleSubmit}
 					onAbort={handleAbort}
 					commands={commandSuggestions}

src/ui/Status.tsx

@@ -46,6 +46,29 @@ const THINKING_VERBS = [
 	"Linking",
 	"Optimizing",
 	"Stashing",
+	"Bisecting",
+	"Memoizing",
+	"Tokenizing",
+	"Hoisting",
+	"Reticulating",
+	"Refactoring",
+	"Bundling",
+	"Pruning",
+	"Spawning",
+	"Crunching",
+	"Marshaling",
+	"Currying",
+	"Folding",
+	"Reducing",
+	"Lexing",
+	"Yak-shaving",
+	"Caching",
+	"Threading",
+	"Vendoring",
+	"Inlining",
+	"Hashing",
+	"Allocating",
+	"Branching",
 ];
 
 const STATUS_LABEL: Record<ChatState["status"], string> = {

src/ui/terminal-title.ts

@@ -1,19 +1,31 @@
 /**
- * Set the terminal window/tab title via OSC 0. Honored by all modern
- * terminals (xterm, iTerm2, Ghostty, kitty) plus the integrated
- * terminals in VS Code, Cursor, JetBrains IDEs — so "node" tabs become
- * "codebase". TMUX/screen forward this through to the host emulator.
+ * Set the terminal window/tab title via two independent channels:
  *
- * No-op on non-TTY stdouts (piped output, CI logs) so we don't pollute
- * captured output with stray escape bytes.
+ * 1. OSC 0 escape — read by xterm, iTerm2, Ghostty, kitty, alacritty,
+ *    gnome-terminal, konsole, and tmux/screen forward it through. This
+ *    is the standard.
+ *
+ * 2. process.title — VS Code and Cursor's integrated terminals show
+ *    "node" by default because their tab-title template defaults to
+ *    `${process}`, which reads the OS process name rather than the OSC
+ *    sequence. Setting process.title changes what the OS reports, so
+ *    VS Code's default template picks up our chosen name.
+ *
+ * Both writes are no-ops on non-TTY stdouts (piped output, CI logs)
+ * so we don't pollute captured output with stray escape bytes.
  *
  * We intentionally don't try to "restore" the prior title on exit:
- * there's no portable way to read the current title, and on shell exit
- * the parent shell's PROMPT_COMMAND / precmd hook will set it back
- * within milliseconds. Setting it to empty would be worse than leaving
- * our title in place during the brief gap.
+ * there's no portable way to read the current title, and the parent
+ * shell's prompt hook resets it within milliseconds anyway.
  */
 export function setTerminalTitle(title: string): void {
 	if (!process.stdout.isTTY) return;
 	process.stdout.write(`\x1b]0;${title}\x07`);
+	try {
+		process.title = title;
+	} catch {
+		// On some platforms / sandboxed environments process.title is
+		// read-only or restricted. The OSC write is the main path; this
+		// is just additional coverage for editor terminals.
+	}
 }