Fix Codex prompt auto-send

Author: johannesjo

src/store/taskStatus.test.ts

@@ -55,6 +55,7 @@ import {
   isTrustQuestionAutoHandled,
   isAutoTrustSettling,
   isAgentAskingQuestion,
+  isAgentBracketedPasteEnabled,
   getTaskAttentionState,
   getTaskDotStatus,
   taskNeedsAttention,
@@ -522,6 +523,56 @@ describe('isAutoTrustSettling', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// bracketed paste mode
+// ---------------------------------------------------------------------------
+describe('isAgentBracketedPasteEnabled', () => {
+  it('tracks bracketed paste enable and disable sequences', () => {
+    markAgentSpawned('agent-1');
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(false);
+
+    markAgentOutput('agent-1', new TextEncoder().encode('\x1b[?2004h'), 'task-1');
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(true);
+
+    markAgentOutput('agent-1', new TextEncoder().encode('\x1b[?2004l'), 'task-1');
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(false);
+  });
+
+  it('uses the last bracketed paste sequence in a chunk', () => {
+    markAgentSpawned('agent-1');
+
+    markAgentOutput(
+      'agent-1',
+      new TextEncoder().encode('\x1b[?2004h redraw \x1b[?2004l exit'),
+      'task-1',
+    );
+
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(false);
+  });
+
+  it('tracks bracketed paste sequences split across PTY chunks', () => {
+    markAgentSpawned('agent-1');
+
+    markAgentOutput('agent-1', new TextEncoder().encode('\x1b[?20'), 'task-1');
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(false);
+
+    markAgentOutput('agent-1', new TextEncoder().encode('04h'), 'task-1');
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(true);
+  });
+
+  it('detects bracketed paste sequence before retained tail in a large chunk', () => {
+    markAgentSpawned('agent-1');
+
+    markAgentOutput(
+      'agent-1',
+      new TextEncoder().encode('\x1b[?2004h' + 'x'.repeat(20_000)),
+      'task-1',
+    );
+
+    expect(isAgentBracketedPasteEnabled('agent-1')).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // task attention
 // ---------------------------------------------------------------------------

src/store/taskStatus.ts

@@ -40,6 +40,7 @@ interface AgentTrackingState {
   lastAnalysisAt?: number;
   pendingAnalysis?: ReturnType<typeof setTimeout>;
   pendingAnalysisDueAt?: number;
+  bracketedPasteEnabled?: boolean;
 }
 
 const agentStates = new Map<string, AgentTrackingState>();
@@ -53,6 +54,18 @@ function getAgentState(agentId: string): AgentTrackingState {
   return state;
 }
 
+function updateBracketedPasteMode(state: AgentTrackingState, text: string): void {
+  // Bracketed paste mode is controlled by CSI ? 2004 h/l.  Track the last
+  // mode switch seen in the new PTY data so synthetic prompt sends can match
+  // terminal paste semantics instead of arriving as rapid raw keystrokes.
+  // eslint-disable-next-line no-control-regex
+  const re = /\x1b\[\?2004([hl])/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    state.bracketedPasteEnabled = m[1] === 'h';
+  }
+}
+
 const POST_AUTO_TRUST_SETTLE_MS = 1_000;
 
 function isAutoTrustPending(agentId: string): boolean {
@@ -431,6 +444,11 @@ export function isAgentAskingQuestion(agentId: string): boolean {
   return questionAgents().has(agentId);
 }
 
+/** True when the agent's terminal has requested bracketed paste mode. */
+export function isAgentBracketedPasteEnabled(agentId: string): boolean {
+  return agentStates.get(agentId)?.bracketedPasteEnabled === true;
+}
+
 function updateQuestionState(agentId: string, hasQuestion: boolean): void {
   setQuestionAgents((prev) => {
     if (hasQuestion === prev.has(agentId)) return prev;
@@ -540,6 +558,7 @@ function scheduleAgentAnalysis(agentId: string, intervalMs: number, now: number)
 export function markAgentSpawned(agentId: string): void {
   const state = getAgentState(agentId);
   state.outputTailBuffer = '';
+  state.bracketedPasteEnabled = false;
   clearAutoTrustState(agentId);
   state.lastAnalysisAt = undefined;
   cancelPendingAnalysis(state);
@@ -632,6 +651,7 @@ export function markAgentOutput(agentId: string, data: Uint8Array, taskId?: stri
   state.lastDataAt = now;
 
   const text = state.decoder.decode(data, { stream: true });
+  updateBracketedPasteMode(state, state.outputTailBuffer.slice(-16) + text);
   const combined = state.outputTailBuffer + text;
   state.outputTailBuffer =
     combined.length > TAIL_BUFFER_MAX

src/store/tasks.test.ts

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { IPC } from '../../electron/ipc/channels';
+
+const { mockInvoke, mockIsAgentBracketedPasteEnabled, mockSetStore, mockStore } = vi.hoisted(
+  () => ({
+    mockInvoke: vi.fn(),
+    mockIsAgentBracketedPasteEnabled: vi.fn(),
+    mockSetStore: vi.fn(),
+    mockStore: {
+      agents: {},
+      tasks: {},
+    } as {
+      agents: Record<string, { status: string }>;
+      tasks: Record<
+        string,
+        {
+          initialPrompt?: string;
+          lastPrompt?: string;
+          stepsEnabled?: boolean;
+        }
+      >;
+    },
+  }),
+);
+
+vi.mock('../lib/ipc', () => ({
+  Channel: vi.fn(),
+  invoke: mockInvoke,
+}));
+
+vi.mock('./core', () => ({
+  setStore: mockSetStore,
+  store: mockStore,
+  cleanupPanelEntries: vi.fn(),
+}));
+
+vi.mock('./persistence', () => ({
+  saveState: vi.fn(),
+}));
+
+vi.mock('./focus', () => ({
+  setTaskFocusedPanel: vi.fn(),
+}));
+
+vi.mock('./projects', () => ({
+  getProject: vi.fn(),
+  getProjectBranchPrefix: vi.fn(),
+  getProjectPath: vi.fn(),
+  isProjectMissing: vi.fn(),
+}));
+
+vi.mock('../lib/bookmarks', () => ({
+  setPendingShellCommand: vi.fn(),
+}));
+
+vi.mock('./taskStatus', () => ({
+  clearAgentActivity: vi.fn(),
+  clearTaskGitStatusTracking: vi.fn(),
+  isAgentBracketedPasteEnabled: mockIsAgentBracketedPasteEnabled,
+  isAgentIdle: vi.fn(),
+  markAgentBusy: vi.fn(),
+  markAgentSpawned: vi.fn(),
+  rescheduleTaskStatusPolling: vi.fn(),
+}));
+
+vi.mock('./completion', () => ({
+  recordMergedLines: vi.fn(),
+  recordTaskCompleted: vi.fn(),
+}));
+
+vi.mock('../lib/log', () => ({
+  warn: vi.fn(),
+}));
+
+import { sendPrompt } from './tasks';
+
+function writePayloads(): string[] {
+  return mockInvoke.mock.calls
+    .filter(([channel]) => channel === IPC.WriteToAgent)
+    .map(([, payload]) => payload.data);
+}
+
+describe('sendPrompt', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockInvoke.mockResolvedValue(undefined);
+    mockIsAgentBracketedPasteEnabled.mockReturnValue(false);
+    mockStore.agents = { 'agent-1': { status: 'running' } };
+    mockStore.tasks = {
+      'task-1': {
+        lastPrompt: '',
+      },
+    };
+  });
+
+  it('wraps prompt text in bracketed paste when the agent enabled it', async () => {
+    mockIsAgentBracketedPasteEnabled.mockReturnValue(true);
+
+    await sendPrompt('task-1', 'agent-1', 'hello Codex');
+
+    expect(writePayloads()).toEqual(['\x1b[I', '\x1b[200~hello Codex\x1b[201~', '\r']);
+    expect(mockSetStore).toHaveBeenCalledWith('tasks', 'task-1', 'lastPrompt', 'hello Codex');
+  });
+
+  it('sends raw prompt text when bracketed paste is not enabled', async () => {
+    await sendPrompt('task-1', 'agent-1', 'hello Codex');
+
+    expect(writePayloads()).toEqual(['\x1b[I', 'hello Codex', '\r']);
+  });
+
+  it('keeps Enter outside the bracketed paste block', async () => {
+    mockIsAgentBracketedPasteEnabled.mockReturnValue(true);
+
+    await sendPrompt('task-1', 'agent-1', 'line 1\nline 2');
+
+    expect(writePayloads()).toEqual(['\x1b[I', '\x1b[200~line 1\nline 2\x1b[201~', '\r']);
+  });
+});

src/store/tasks.ts

@@ -11,6 +11,7 @@ import {
   markAgentBusy,
   clearAgentActivity,
   clearTaskGitStatusTracking,
+  isAgentBracketedPasteEnabled,
   isAgentIdle,
   rescheduleTaskStatusPolling,
 } from './taskStatus';
@@ -52,6 +53,8 @@ function initTaskInStore(
 
 const AGENT_WRITE_READY_TIMEOUT_MS = 8_000;
 const AGENT_WRITE_RETRY_MS = 50;
+const BRACKETED_PASTE_START = '\x1b[200~';
+const BRACKETED_PASTE_END = '\x1b[201~';
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -477,9 +480,16 @@ export async function sendPrompt(taskId: string, agentId: string, text: string):
   // to the PTY, which may suspend readline input processing; \x1b[I re-activates it.
   await writeToAgentWhenReady(agentId, '\x1b[I');
   // Send text and Enter separately so TUI apps (Claude Code, Codex)
-  // don't treat the \r as part of a pasted block
+  // don't treat the \r as part of a pasted block.  When the agent has enabled
+  // bracketed paste, wrap only the prompt text; this avoids Codex's paste-burst
+  // guard treating rapid synthetic keystrokes plus Enter as a paste.
   setTaskLastInputAt(taskId);
-  await writeToAgentWhenReady(agentId, effectiveText);
+  await writeToAgentWhenReady(
+    agentId,
+    isAgentBracketedPasteEnabled(agentId)
+      ? `${BRACKETED_PASTE_START}${effectiveText}${BRACKETED_PASTE_END}`
+      : effectiveText,
+  );
   await new Promise((r) => setTimeout(r, 50));
   await writeToAgentWhenReady(agentId, '\r');
   setStore('tasks', taskId, 'lastPrompt', text);