fix(ctrl-c): single tap aborts, second tap within 1s exits — no hung state

Three independent things were combining to make ctrl-c feel broken:

1. ink's default exitOnCtrlC unmounts the React tree without exiting
   the Node process. The user saw a frozen terminal — the "weird state
   where I can't type to AI." A second ctrl-c finally killed the
   process via our SIGINT handler.

2. The Permission overlay had no ctrl-c binding, so hitting ctrl-c
   during an approval prompt did nothing visible.

3. After abort fired, the abandoned turn's trailing turn_end / agent_end
   events flipped status back to thinking / idle — re-disabling the
   input.

Disable ink's exitOnCtrlC and own ctrl-c at the App root: dismiss any
overlay first (deny permission, cancel user query), then abort the
agent if busy, then arm the 1-second double-tap exit window. Reducer
now ignores turn_end / agent_end while status === "aborted" so the
abandoned turn can't re-disable the input.

Author: halfaipg

package.json

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

src/agent/events.test.ts

@@ -427,3 +427,58 @@ describe("reducer · usage merging", () => {
 		expect(s.usage.totalTokens).toBe(100);
 	});
 });
+
+describe("reducer · post-abort event suppression", () => {
+	it("ignores turn_end while status is aborted (would otherwise re-disable input)", () => {
+		let s = dispatch(freshState(), { type: "agent-event", event: { type: "agent_start" } as AgentEvent });
+		expect(s.status).toBe("thinking");
+		s = dispatch(s, { type: "abort" });
+		expect(s.status).toBe("aborted");
+		// Abandoned turn's tail arrives — must NOT flip us to thinking.
+		s = dispatch(s, { type: "agent-event", event: { type: "turn_end" } as AgentEvent });
+		expect(s.status).toBe("aborted");
+	});
+
+	it("ignores agent_end while status is aborted", () => {
+		const s = dispatch(
+			{ ...freshState(), status: "aborted" },
+			{
+				type: "agent-event",
+				event: { type: "agent_end" } as AgentEvent,
+			},
+		);
+		expect(s.status).toBe("aborted");
+	});
+
+	it("a subsequent user-prompt clears the aborted state and starts a fresh turn", () => {
+		const s = dispatch({ ...freshState(), status: "aborted" }, { type: "user-prompt", text: "try again" });
+		expect(s.status).toBe("thinking");
+	});
+
+	it("still applies tool_execution_end while aborted so spinners clear visually", () => {
+		let s = dispatch(freshState(), {
+			type: "agent-event",
+			event: {
+				type: "tool_execution_start",
+				toolCallId: "t1",
+				toolName: "shell",
+				args: {},
+			} as unknown as AgentEvent,
+		});
+		s = dispatch(s, { type: "abort" });
+		expect(s.status).toBe("aborted");
+		expect(s.tools.get("t1")?.status).toBe("running");
+		s = dispatch(s, {
+			type: "agent-event",
+			event: {
+				type: "tool_execution_end",
+				toolCallId: "t1",
+				result: "interrupted",
+				isError: true,
+			} as unknown as AgentEvent,
+		});
+		expect(s.tools.get("t1")?.status).toBe("error");
+		// Status itself stays "aborted" — we don't let the abandoned turn flip it.
+		expect(s.status).toBe("aborted");
+	});
+});

src/agent/events.ts

@@ -64,6 +64,14 @@ export function reducer(state: ChatState, action: Action): ChatState {
 			return initialState(state.model);
 
 		case "agent-event":
+			// When the user has aborted a turn, ignore the abandoned turn's
+			// tail events that would flip status back to thinking/idle (and
+			// thus re-disable the input). The next user-prompt action resets
+			// status cleanly. Tool execution and message events still apply
+			// so any in-flight spinners and partial messages settle visually.
+			if (state.status === "aborted" && (action.event.type === "turn_end" || action.event.type === "agent_end")) {
+				return state;
+			}
 			return applyAgentEvent(state, action.event);
 	}
 }

src/cli.tsx

@@ -85,7 +85,11 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 	// collapses the content into a placeholder. terminal-restore.ts emits
 	// the matching disable sequence on every exit path.
 	if (process.stdout.isTTY) process.stdout.write("\x1b[?2004h");
-	const instance = render(<App />);
+	// Disable ink's default ctrl-c handling. ink unmounts on ctrl-c but
+	// doesn't exit the process — leaves the user staring at a frozen
+	// terminal. We handle ctrl-c ourselves: first press aborts the agent
+	// and any in-flight overlay, a second press within 1s exits cleanly.
+	const instance = render(<App />, { exitOnCtrlC: false });
 	installTerminalRestoreHandlers(instance);
 	instance.waitUntilExit().catch(() => {
 		process.exit(1);

src/ui/App.tsx

@@ -1,4 +1,4 @@
-import { Box, Text, useApp } from "ink";
+import { Box, Text, useApp, useInput } from "ink";
 import { useEffect, useMemo, useReducer, useState } from "react";
 import { type AgentBundle, createAgent } from "../agent/agent.js";
 import { ConfigError } from "../agent/config.js";
@@ -218,11 +218,14 @@ function ChatApp({ bundle, onExit }: ChatAppProps) {
 	};
 
 	// Ctrl-C semantics:
+	//   • Any open overlay (Permission, UserQuery) gets dismissed first
+	//     so the user is never trapped behind a prompt with no escape.
 	//   • While the agent is busy: abort the turn. Stays in the app.
 	//   • A second Ctrl-C within DOUBLE_TAP_MS exits, regardless of
 	//     whether the previous press aborted or just landed a hint.
 	//     "Twice real fast" is universally understood as "I want out."
-	//   • While idle: first press posts a hint + arms the exit window.
+	//   • While idle at the prompt: first press posts a hint + arms the
+	//     exit window so the second tap exits.
 	//
 	// 1000ms is "real fast" — wide enough that intentional double-taps
 	// register, tight enough that mashing Ctrl-C twice while flustered
@@ -236,6 +239,29 @@ function ChatApp({ bundle, onExit }: ChatAppProps) {
 			return;
 		}
 		exitTimerRef.deadline = now + DOUBLE_TAP_MS;
+
+		// Overlays first: dismissing them brings the user back to a usable
+		// input row without exiting the agent loop. Permission denies the
+		// pending request (and any tool waiting on it surfaces the denial
+		// to the model as a normal tool error); UserQuery cancels the
+		// pending question.
+		if (permRequest) {
+			bundle.permissions.respond(permRequest.id, "deny");
+			if (busy) {
+				bundle.agent.abort();
+				dispatch({ type: "abort" });
+			}
+			return;
+		}
+		if (userQuery) {
+			bundle.userQueries.cancel(userQuery.id);
+			if (busy) {
+				bundle.agent.abort();
+				dispatch({ type: "abort" });
+			}
+			return;
+		}
+
 		if (busy) {
 			bundle.agent.abort();
 			dispatch({ type: "abort" });
@@ -247,6 +273,14 @@ function ChatApp({ bundle, onExit }: ChatAppProps) {
 		appendStatus("Press Ctrl-C again to exit.");
 	};
 
+	// Top-level Ctrl-C capture. Fires regardless of which child component
+	// is mounted (Input, Permission, UserQuery) so the user always has a
+	// way out. The per-component handlers stay for their other shortcuts
+	// (Esc to deny, etc.) but Ctrl-C now routes through here.
+	useInput((input, key) => {
+		if (key.ctrl && input === "c") handleAbort();
+	});
+
 	return (
 		<Box flexDirection="column">
 			{state.messages.length === 0 && !state.streaming ? (

src/ui/Input.tsx

@@ -147,10 +147,10 @@ export function Input({
 		// we can diagnose "key X doesn't work" reports from real terminals.
 		logInputEvent(input, key);
 
-		if (key.ctrl && input === "c") {
-			onAbort?.();
-			return;
-		}
+		// Ctrl-C is owned by App's top-level useInput (it needs to fire
+		// even when Input is hidden behind an overlay). Swallow it here
+		// so we don't double-dispatch onAbort.
+		if (key.ctrl && input === "c") return;
 
 		if (disabled) return;