fix(codex): a message your Codex hook blocks no longer leaves the chat Working forever

mobile/src/session/mobile-structured-send-delivery.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it } from 'vitest'
+import { agentSessionFailureFact } from '../../../src/shared/agent-session-failure'
+import { agentSessionFailureWords } from '../../../src/shared/agent-session-failure-words'
 import type { AgentJournalDispatchState } from '../../../src/shared/agent-session-journal-types'
 import type { AgentSessionSendResult } from '../../../src/shared/agent-session-wire'
 import { mobileStructuredSendDelivery } from './mobile-structured-send-delivery'
@@ -125,6 +127,34 @@ describe('mobileStructuredSendDelivery', () => {
     })
   })
 
+  it('reports a send its own hook blocked as sent, never handing its text back', () => {
+    // Drawn as a sent message on every client, so a restored draft would show it twice.
+    const answer = structuredSendResultFixture('rejected')
+    if (!('submission' in answer)) {
+      throw new Error('the fixture answers with a submission')
+    }
+    const blocked: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
+      status: 'accepted',
+      value: {
+        ...answer,
+        submission: {
+          ...answer.submission,
+          ...agentSessionFailureWords(
+            agentSessionFailureFact('hookBlocked', {
+              detail: { text: 'No secrets in prompts.', audience: 'person' }
+            }),
+            { surface: 'rejection', agentName: 'Codex' }
+          )
+        }
+      }
+    }
+    expect(mobileStructuredSendDelivery(blocked)).toEqual({
+      outcome: 'accepted',
+      operationIdSpent: true,
+      error: null
+    })
+  })
+
   it('shows a provider content rejection verbatim', () => {
     expect(
       mobileStructuredSendDelivery(accepted('rejected', 'Claude does not support .bmp'))

mobile/src/session/mobile-structured-send-delivery.ts

@@ -32,6 +32,7 @@ import type { AgentSessionSendResult } from '../../../src/shared/agent-session-w
 import { agentSessionRefusalOperationState } from '../../../src/shared/agent-session-refusal-retry'
 import { agentSessionWriteNoticeEnglish } from '../../../src/shared/agent-session-refusal-notice'
 import { structuredAgentSessionRejectionNotice } from '../../../src/shared/structured-agent-session-send-disposition'
+import { rejectionDrawnAsSent } from '../../../src/shared/structured-agent-session-dispatch-rejection'
 import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
 import type { StructuredAgentSessionMutationCallResult } from './mobile-structured-agent-session-rpc'
 
@@ -98,6 +99,10 @@ export function mobileStructuredSendDelivery(
   if (!submission || submission.dispatchState === 'unknown') {
     return { outcome: 'unknown', operationIdSpent: false, error: null }
   }
+  if (rejectionDrawnAsSent(submission)) {
+    // Every client draws it as sent, so its text handed back to the composer would show it twice.
+    return { outcome: 'accepted', operationIdSpent: true, error: null }
+  }
   if (submission.dispatchState === 'rejected') {
     return {
       outcome: 'rejected',

mobile/src/session/use-mobile-structured-agent-session-rejected-rows.test.tsx

@@ -0,0 +1,142 @@
+import { createElement } from 'react'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+import { afterEach, expect, it, vi } from 'vitest'
+import { agentSessionFailureFact } from '../../../src/shared/agent-session-failure'
+import { agentSessionFailureWords } from '../../../src/shared/agent-session-failure-words'
+import { agentJournalSubmissionKey } from '../../../src/shared/agent-session-journal-item-key'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../src/shared/agent-session-journal-types'
+import type { AgentSessionSubscribeEvent } from '../../../src/shared/agent-session-wire'
+import type { RpcClient } from '../transport/rpc-client'
+import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
+
+vi.mock('@react-native-async-storage/async-storage', () => ({
+  default: { getItem: vi.fn(async () => null), setItem: vi.fn(), removeItem: vi.fn() }
+}))
+
+const MESSAGE: AgentJournalRenderItem = {
+  itemId: agentJournalSubmissionKey('op-undelivered'),
+  revision: 0,
+  sequence: 1,
+  observedAt: 1,
+  body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'never got it' }] }
+}
+
+/** Handed over, then the agent's history showed it never got it. */
+const UNDELIVERED: AgentJournalSubmission = {
+  clientMessageId: 'op-undelivered',
+  fence: 3,
+  payloadFingerprint: 'fingerprint',
+  dispatchState: 'rejected',
+  providerItemId: null,
+  submittedAt: 1,
+  resolvedAt: 2,
+  handoverRecorded: true,
+  handedOverAt: 1,
+  recovered: true,
+  ...agentSessionFailureWords(agentSessionFailureFact('notDelivered'), { surface: 'rejection' })
+}
+
+/** A Codex hook blocked it: a rejection of its own kind, with the host's sentence beside it. */
+const HOOK_BLOCKED: AgentJournalSubmission = {
+  ...UNDELIVERED,
+  ...agentSessionFailureWords(
+    agentSessionFailureFact('hookBlocked', {
+      detail: { text: 'No secrets in prompts.', audience: 'person' }
+    }),
+    { surface: 'rejection', agentName: 'Codex' }
+  )
+}
+
+function snapshot(submission: AgentJournalSubmission = UNDELIVERED): AgentSessionSubscribeEvent {
+  return {
+    type: 'snapshot',
+    sessionId: 'session-1',
+    fence: 3,
+    page: {
+      sessionId: 'session-1',
+      epoch: 'epoch-1',
+      fence: 3,
+      direction: 'tail',
+      items: [MESSAGE],
+      removedItemIds: [],
+      submissions: [submission],
+      window: {
+        oldest: { epoch: 'epoch-1', sequence: 1 },
+        newest: { epoch: 'epoch-1', sequence: 1 },
+        nextCursor: { epoch: 'epoch-1', sequence: 2 }
+      },
+      liveCursor: { epoch: 'epoch-1', sequence: 1 },
+      hasOlder: false,
+      hasNewer: false
+    }
+  }
+}
+
+// Module scope: the harness assigns these, which a test body's own `let` would narrow to null.
+let renderer: ReactTestRenderer | null = null
+let hook: ReturnType<typeof useMobileStructuredAgentSession> | null = null
+let listener: ((value: unknown) => void) | null = null
+afterEach(() => {
+  act(() => renderer?.unmount())
+  renderer = null
+  hook = null
+  listener = null
+})
+
+/** The messages the phone's chat draws once the host's page holds this submission. */
+async function phoneMessages(submission: AgentJournalSubmission) {
+  const client: RpcClient = {
+    sendRequest: async () => ({
+      id: 'request-1',
+      ok: true,
+      result: {},
+      _meta: { runtimeId: 'runtime-1' }
+    }),
+    subscribe: (_method, _params, onData) => {
+      listener = onData
+      return () => {}
+    },
+    updateTerminalSubscriptionViewport: () => {},
+    getState: () => 'connected',
+    getReconnectAttempt: () => 0,
+    getLastConnectedAt: () => null,
+    onStateChange: () => () => {},
+    notifyForeground: () => {},
+    close: () => {}
+  }
+  function Harness(): null {
+    hook = useMobileStructuredAgentSession({
+      client,
+      sessionId: 'session-1',
+      sourceIdentity: 'host-a\0workspace-a',
+      enabled: true,
+      connected: true,
+      agent: 'claude',
+      hostSupport: null,
+      onSendError: vi.fn()
+    })
+    return null
+  }
+
+  await act(async () => {
+    renderer = create(createElement(Harness))
+  })
+  await vi.waitFor(() => expect(listener).toEqual(expect.any(Function)))
+  act(() => listener?.(snapshot(submission)))
+  return hook?.session.messages
+}
+
+// The phone does not mark a message as unsent yet; drawn, it would look delivered.
+it('keeps a message the agent never got hidden, as before', async () => {
+  expect(await phoneMessages(UNDELIVERED)).toEqual([])
+})
+
+// Before the block was known it was drawn as sent; it stays so rather than vanish.
+it('draws a message a Codex hook blocked as sent, as before', async () => {
+  const messages = await phoneMessages(HOOK_BLOCKED)
+  expect(messages?.map(({ id }) => id)).toEqual([agentJournalSubmissionKey('op-undelivered')])
+  expect(messages?.[0]).not.toHaveProperty('unsent')
+})

src/main/codex/codex-structured-dispatch-echo.ts

@@ -3,6 +3,7 @@ import type {
   AgentJournalItemIdentity,
   AgentJournalTurnJoin
 } from '../../shared/agent-session-journal-types'
+import type { CodexPromptBlock } from './codex-structured-prompt-block'
 
 /** Sends awaiting their echo. One bound to a turn that ended without taking it settles from that
  *  end; any other whose echo never arrives is retired by the journal's recovery on exit. */
@@ -11,9 +12,10 @@ export const MAX_CODEX_PENDING_DISPATCH_ECHOES = 256
  *  turns kept that Codex left unopened through a wait. */
 export const MAX_CODEX_RECORDED_TURN_ENDS = 64
 
-/** How a primary-thread turn ended, as Codex reported it. */
+/** How a primary-thread turn ended, as Codex reported it. `blocked`: a Codex hook blocked a prompt
+ *  in that turn, which Codex then never recorded. */
 export type CodexTurnEnd =
-  | { status: 'completed' }
+  | { status: 'completed'; blocked?: CodexPromptBlock }
   | { status: 'interrupted' }
   | { status: 'failed'; detail?: ProviderDiagnostic }
 
@@ -52,12 +54,18 @@ export type CodexDispatchEchoes = {
   answeredUnopenedTurn: (threadId: string, openTurnIds: ReadonlySet<string>) => string | null
   /** Codex did not open this answered turn within a wait, so no later wait is spent on it. */
   leftUnopened: (threadId: string, turnId: string) => void
+  /** Codex reported a Codex hook blocked a prompt in this turn, kept only until the turn ends: the
+   *  first message to the person and the first block reason any of its hooks gave. */
+  blockPrompt: (threadId: string, turnId: string, block: CodexPromptBlock) => void
+  /** The block reported in this turn, which its end takes; null when none was. */
+  takePromptBlock: (threadId: string, turnId: string) => CodexPromptBlock | null
   /** The latest armed send's answered turn a wait left unopened, neither open nor ended: Codex may
    *  still open it, though no wait is spent on it again. */
   answeredTurnLeftUnopened: (threadId: string, openTurnIds: ReadonlySet<string>) => string | null
   /**
    * Records a turn's end and returns the sends bound to it that it settles: all of them unless it
-   * completed, which echoes its pending input first, so one it never echoed waits for recovery. An
+   * completed, which echoes its pending input first, so one it never echoed waits for recovery,
+   * unless a hook blocked a prompt in it: Codex records nothing it blocked. An
    * interrupt withdraws an un-echoed send, steered or the turn's own input: neither reached history.
    */
   endTurn: (
@@ -84,9 +92,11 @@ export function createCodexDispatchEchoes(): CodexDispatchEchoes {
   >()
   const endedTurns = new Map<string, CodexTurnEnd>()
   const unopenedTurns = new Set<string>()
+  const blockedTurns = new Map<string, CodexPromptBlock>()
   let nextSequence = 0
   const turnKey = (threadId: string, turnId: string): string => JSON.stringify([threadId, turnId])
-  const settles = (end: CodexTurnEnd): boolean => end.status !== 'completed'
+  const settles = (end: CodexTurnEnd): boolean =>
+    end.status !== 'completed' || end.blocked !== undefined
   const answeredTurn = (
     threadId: string,
     openTurnIds: ReadonlySet<string>,
@@ -142,6 +152,28 @@ export function createCodexDispatchEchoes(): CodexDispatchEchoes {
         unopenedTurns.delete(oldest)
       }
     },
+    blockPrompt: (threadId, turnId, block) => {
+      const turn = turnKey(threadId, turnId)
+      // Codex reports hooks in their configured order and stops for the first block reason; a
+      // hook's message to the person is never that reason, so each keeps its first separately.
+      const earlier = blockedTurns.get(turn)
+      const warning = earlier?.warning ?? block.warning
+      const stop = earlier?.stop ?? block.stop
+      blockedTurns.delete(turn)
+      blockedTurns.set(turn, { ...(warning ? { warning } : {}), ...(stop ? { stop } : {}) })
+      for (const oldest of blockedTurns.keys()) {
+        if (blockedTurns.size <= MAX_CODEX_RECORDED_TURN_ENDS) {
+          break
+        }
+        blockedTurns.delete(oldest)
+      }
+    },
+    takePromptBlock: (threadId, turnId) => {
+      const turn = turnKey(threadId, turnId)
+      const block = blockedTurns.get(turn) ?? null
+      blockedTurns.delete(turn)
+      return block
+    },
     endTurn: (threadId, turnId, end) => {
       const turn = turnKey(threadId, turnId)
       endedTurns.delete(turn)
@@ -176,6 +208,7 @@ export function createCodexDispatchEchoes(): CodexDispatchEchoes {
       armed.clear()
       endedTurns.clear()
       unopenedTurns.clear()
+      blockedTurns.clear()
       nextSequence = 0
     },
     get size() {