Native chat: desktop and mobile read the host's working answer; plain refusal for a stopped agent's prompt (3/5, rebuild of #26867)

config/scripts/vitest-sqlite-runtime-files.mjs

@@ -124,6 +124,7 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-late-proof-tool-ends.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-late-settlement.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-lease-renewer.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-ended-prompt-cancel.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-legacy-handoff-record.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-live-turn-window.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-main-agent-working-agreement.test.ts',

mobile/src/session/mobile-structured-actionable-prompt.ts

@@ -0,0 +1,33 @@
+import { isActionableStructuredAgentSessionPrompt } from '../../../src/shared/structured-agent-session-live-turn'
+import type { StructuredAgentSessionState } from '../../../src/shared/structured-agent-session-reducer'
+import {
+  pendingStructuredApproval,
+  pendingStructuredQuestion,
+  type StructuredApprovalItem,
+  type StructuredQuestionItem
+} from './mobile-structured-agent-prompts'
+
+type PromptState = Pick<StructuredAgentSessionState, 'items' | 'actionablePromptIds'>
+
+/** The approval a person can answer: pending, and named by the host as waiting when it names them
+ *  (`isActionableStructuredAgentSessionPrompt`): one an agent that ended raised is not. */
+export function actionableStructuredApproval(state: PromptState): StructuredApprovalItem | null {
+  return (
+    state.items.find(
+      (item): item is StructuredApprovalItem =>
+        pendingStructuredApproval(item) &&
+        isActionableStructuredAgentSessionPrompt(item.itemId, state.actionablePromptIds)
+    ) ?? null
+  )
+}
+
+/** The question a person can answer, by the same rule. */
+export function actionableStructuredQuestion(state: PromptState): StructuredQuestionItem | null {
+  return (
+    state.items.find(
+      (item): item is StructuredQuestionItem =>
+        pendingStructuredQuestion(item) &&
+        isActionableStructuredAgentSessionPrompt(item.itemId, state.actionablePromptIds)
+    ) ?? null
+  )
+}

mobile/src/session/mobile-structured-agent-session-cancel.ts

@@ -1,7 +1,9 @@
 import type { AgentSessionCancelResult } from '../../../src/shared/agent-session-wire'
-import type { AgentJournalRenderItem } from '../../../src/shared/agent-session-journal-types'
 import type { StructuredAgentSessionState } from '../../../src/shared/structured-agent-session-reducer'
-import { runningStructuredAgentSessionTurnId } from '../../../src/shared/structured-agent-session-live-turn'
+import {
+  isActionableStructuredAgentSessionPrompt,
+  runningStructuredAgentSessionTurnId
+} from '../../../src/shared/structured-agent-session-live-turn'
 import type { RpcClient } from '../transport/rpc-client'
 import {
   requestStructuredAgentSessionMutation,
@@ -10,12 +12,14 @@ import {
 
 type PromptIdentity = { itemId: string; expectedRevision: number }
 
+/** The prompt a Stop cancels: one the host says still waits on the person, when it says. */
 export function pendingStructuredPromptIdentity(
-  items: readonly AgentJournalRenderItem[]
+  state: Pick<StructuredAgentSessionState, 'items' | 'actionablePromptIds'>
 ): PromptIdentity | undefined {
-  const prompt = items.find((item) =>
+  const prompt = state.items.find((item) =>
     item.body.kind === 'approval' || item.body.kind === 'question'
-      ? item.body.resolution.state === 'pending'
+      ? item.body.resolution.state === 'pending' &&
+        isActionableStructuredAgentSessionPrompt(item.itemId, state.actionablePromptIds)
       : false
   )
   return prompt ? { itemId: prompt.itemId, expectedRevision: prompt.revision } : undefined

mobile/src/session/mobile-structured-agent-session-rpc.ts

@@ -127,6 +127,8 @@ export async function requestStructuredAgentSessionMutation<TValue>(args: {
   fields: Record<string, unknown>
   clientOperationId?: string
   timeoutMs?: number
+  /** The chat's agent, which a refusal about it names. */
+  agentName?: string
 }): Promise<StructuredAgentSessionMutationCallResult<TValue>> {
   const {
     client,
@@ -136,8 +138,10 @@ export async function requestStructuredAgentSessionMutation<TValue>(args: {
     expectedRuntimeFence,
     fields,
     clientOperationId,
-    timeoutMs
+    timeoutMs,
+    agentName
   } = args
+  const context = agentName ? { agentName } : {}
   try {
     const result = await callAgentSession<AgentSessionMutationResult<TValue>>(
       client,
@@ -171,7 +175,8 @@ export async function requestStructuredAgentSessionMutation<TValue>(args: {
           code: result.refusal.code,
           message: agentSessionRefusalNotice(
             result.refusal,
-            phoneWriteKind(fingerprintMethod, fields)
+            phoneWriteKind(fingerprintMethod, fields),
+            context
           )
         }
   } catch (error) {
@@ -184,7 +189,7 @@ export async function requestStructuredAgentSessionMutation<TValue>(args: {
       return {
         status: 'failed',
         message: agentSessionWriteNoticeEnglish(
-          agentSessionWriteNoticeParts(answered, phoneWriteKind(fingerprintMethod, fields))
+          agentSessionWriteNoticeParts(answered, phoneWriteKind(fingerprintMethod, fields), context)
         )
       }
     }

mobile/src/session/use-mobile-native-chat-turn-disclosure.ts

@@ -145,7 +145,8 @@ export function useMobileNativeChatTurnDisclosure({
           rows,
           turnJournal?.items,
           stopping,
-          turnJournal?.submissions
+          turnJournal?.submissions,
+          turnJournal ?? {}
         )
       : null
     if (!ids?.size) {

mobile/src/session/use-mobile-structured-agent-mutation.ts

@@ -22,8 +22,10 @@ export function useMobileStructuredAgentMutate(args: {
   enabled: boolean
   stateRef: { readonly current: StructuredAgentSessionState }
   onSendError: (message: string) => void
+  /** The chat's agent, which a refusal about it names. */
+  agentName?: string
 }): MobileStructuredAgentMutate {
-  const { client, enabled, onSendError, sessionId, stateRef } = args
+  const { agentName, client, enabled, onSendError, sessionId, stateRef } = args
   return useCallback(
     async <TValue>(
       method: string,
@@ -41,7 +43,8 @@ export function useMobileStructuredAgentMutate(args: {
         fingerprintMethod,
         sessionId,
         expectedRuntimeFence: targetFence,
-        fields
+        fields,
+        ...(agentName ? { agentName } : {})
       })
       if (result.status === 'accepted') {
         return {
@@ -56,6 +59,6 @@ export function useMobileStructuredAgentMutate(args: {
       onSendError(result.message)
       return { status: 'rejected' }
     },
-    [client, enabled, onSendError, sessionId, stateRef]
+    [agentName, client, enabled, onSendError, sessionId, stateRef]
   )
 }

mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx

@@ -268,6 +268,22 @@ describe('mobile structured prompt cancellation', () => {
     expect(hook.turnId).toBeNull()
   })
 
+  it("reads Working from the host's answer, and from its rows only when an older host gives none", () => {
+    // A turn row an agent that has since ended left running: the host says it is not working.
+    state = { ...state, items: [runningTurn()], working: false }
+    act(() => {
+      renderer = create(createElement(Harness, { promptCancelSupported: true }))
+    })
+    expect(hook.isWorking).toBe(false)
+    act(() => renderer?.unmount())
+    const { working: _answered, ...olderHost } = state
+    state = olderHost
+    act(() => {
+      renderer = create(createElement(Harness, { promptCancelSupported: true }))
+    })
+    expect(hook.isWorking).toBe(true)
+  })
+
   it('uses the rendered prompt identity when the journal changes before tap', async () => {
     act(() => {
       renderer = create(createElement(Harness, { promptCancelSupported: true }))

mobile/src/session/use-mobile-structured-agent-session.ts

@@ -7,12 +7,15 @@ import { isStructuredAgentSessionMainAgentWorking } from '../../../src/shared/st
 import { isFinalAgentSessionReadRefusal } from '../../../src/shared/structured-agent-session-read-refusal'
 import {
   isStructuredAgentSessionThinking,
-  runningStructuredAgentSessionTurnId
+  runningStructuredAgentSessionTurnId,
+  structuredAgentSessionHostSaysWorking
 } from '../../../src/shared/structured-agent-session-live-turn'
 import { selectStructuredAgentTurnActivity } from '../../../src/shared/native-chat-turn-activity'
 import {
-  pendingStructuredApproval,
-  pendingStructuredQuestion,
+  actionableStructuredApproval,
+  actionableStructuredQuestion
+} from './mobile-structured-actionable-prompt'
+import {
   projectStructuredPermission,
   projectStructuredQuestion
 } from './mobile-structured-agent-prompts'
@@ -91,7 +94,8 @@ export function useMobileStructuredAgentSession(args: {
     sessionId,
     enabled,
     stateRef,
-    onSendError
+    onSendError,
+    ...(agent ? { agentName: tuiAgentDisplayName(agent) ?? agent } : {})
   })
 
   const optionStamp = useMobileStructuredSessionOptionStamp({
@@ -159,7 +163,10 @@ export function useMobileStructuredAgentSession(args: {
   const activityText =
     selectStructuredAgentTurnActivity(state.items, turnId, state.activity)?.text ?? null
   const thinking = isStructuredAgentSessionThinking(state)
-  const isWorking = isStructuredAgentSessionMainAgentWorking(turnId, state.submissions, state.fence)
+  // The host's answer counts only the agent running now; an older host gives none.
+  const isWorking = structuredAgentSessionHostSaysWorking(state.working, () =>
+    isStructuredAgentSessionMainAgentWorking(turnId, state.submissions, state.fence)
+  )
   const backgroundTasks = useMobileStructuredBackgroundTasks({
     sessionKey,
     state,
@@ -214,14 +221,11 @@ export function useMobileStructuredAgentSession(args: {
     [thinking, activityText, stopping, stopRequestInFlight, queueCapable, state.items]
   )
   const status = state.status === 'idle' ? 'idle' : state.status
-  const approvalPrompt = useMemo(
-    () => state.items.find(pendingStructuredApproval) ?? null,
-    [state.items]
-  )
-  const questionPrompt = useMemo(
-    () => state.items.find(pendingStructuredQuestion) ?? null,
-    [state.items]
-  )
+  // The host's answer where it gives one: a prompt an agent that ended raised takes no answer.
+  const [approvalPrompt, questionPrompt] = useMemo(() => {
+    const prompts = { items: state.items, actionablePromptIds: state.actionablePromptIds }
+    return [actionableStructuredApproval(prompts), actionableStructuredQuestion(prompts)] as const
+  }, [state.items, state.actionablePromptIds])
   // What a refused command's line on the phone stands on.
   const commandRefusalCauses = useMemo(
     () => ({
@@ -237,7 +241,7 @@ export function useMobileStructuredAgentSession(args: {
     queuedMessages,
     queuePause,
     submissions: state.submissions,
-    agentWorking: isStructuredAgentSessionMainAgentWorking(turnId, state.submissions, state.fence),
+    agentWorking: isWorking,
     mutate,
     appendComposerText,
     onSendError,
@@ -299,7 +303,7 @@ export function useMobileStructuredAgentSession(args: {
       void stopPress.track(() => requestCancel())
     },
     cancelPrompt: (prompt?: { itemId: string; expectedRevision: number }) =>
-      requestCancel(prompt ?? pendingStructuredPromptIdentity(stateRef.current.items)),
+      requestCancel(prompt ?? pendingStructuredPromptIdentity(stateRef.current)),
     permission: projectStructuredPermission(approvalPrompt),
     question: projectStructuredQuestion(questionPrompt, groupedDraft),
     respondPermission,

mobile/src/session/use-mobile-structured-agent-turn-timing.ts

@@ -21,11 +21,14 @@ export function useMobileStructuredAgentTurnTiming(
     items,
     submissions,
     latestTurn,
+    working,
     hostClock
   }: {
     items: readonly AgentJournalRenderItem[]
     submissions: readonly AgentJournalSubmission[]
     latestTurn?: AgentSessionLatestTurn | null
+    /** The host's working answer, which places rows waiting behind the live turn. */
+    working?: boolean
     hostClock?: StructuredAgentHostClock | null
   },
   turnId: string | null
@@ -40,8 +43,8 @@ export function useMobileStructuredAgentTurnTiming(
     [items, submissions, turnId, latestTurn]
   )
   const turnJournal = useMemo(
-    () => ({ items, submissions, latestTurn }),
-    [items, submissions, latestTurn]
+    () => ({ items, submissions, latestTurn, ...(working !== undefined ? { working } : {}) }),
+    [items, submissions, latestTurn, working]
   )
   const [latch, setLatch] = useState<StructuredAgentTurnClockLatch | null>(null)
   // Stamp during render (React's derive-from-props pattern) so the first paint of

mobile/src/session/use-mobile-structured-prompt-responses.ts

@@ -8,8 +8,10 @@ import {
 } from '../../../src/shared/agent-session-question-answer'
 import type { StructuredAgentSessionState } from '../../../src/shared/structured-agent-session-reducer'
 import {
-  pendingStructuredApproval,
-  pendingStructuredQuestion,
+  actionableStructuredApproval,
+  actionableStructuredQuestion
+} from './mobile-structured-actionable-prompt'
+import {
   structuredApprovalResponseTarget,
   structuredQuestionResponseTarget
 } from './mobile-structured-agent-prompts'
@@ -54,7 +56,7 @@ export function useMobileStructuredPromptResponses(args: {
     async (optionId: string): Promise<boolean> => {
       const target = structuredApprovalResponseTarget(
         optionId,
-        stateRef.current.items.find(pendingStructuredApproval) ?? null
+        actionableStructuredApproval(stateRef.current)
       )
       if (!target) {
         return false
@@ -107,7 +109,7 @@ export function useMobileStructuredPromptResponses(args: {
 
   const respondQuestion = useCallback(
     async (answer: string): Promise<boolean> => {
-      const prompt = stateRef.current.items.find(pendingStructuredQuestion) ?? null
+      const prompt = actionableStructuredQuestion(stateRef.current)
       if (prompt?.body.questions) {
         const promptKey = groupedQuestionPromptKey(prompt.itemId, prompt.revision)
         const grouped = advanceGroupedQuestion({

mobile/src/session/use-mobile-structured-send-with-outcome.ts

@@ -22,9 +22,9 @@ import { structuredSessionOperationId } from './structured-session-operation-id'
 import { timeoutForDeadline } from './mobile-structured-agent-session-rpc'
 import { structuredAgentSessionSendSelection } from '../../../src/shared/structured-agent-session-option-view'
 import {
-  pendingStructuredApproval,
-  pendingStructuredQuestion
-} from './mobile-structured-agent-prompts'
+  actionableStructuredApproval,
+  actionableStructuredQuestion
+} from './mobile-structured-actionable-prompt'
 
 /** Whether a send made now asks the host to queue it. The host's queue waits on any pending prompt;
  *  one this build cannot answer would hold the send forever, so it starts a turn instead. */
@@ -113,9 +113,8 @@ export function useMobileStructuredSendWithOutcome(args: {
         pending: commandPending,
         controller: { agent: agent ?? undefined, ...controller },
         busy: () =>
-          stateRef.current.items.some(
-            (item) => pendingStructuredApproval(item) || pendingStructuredQuestion(item)
-          )
+          actionableStructuredApproval(stateRef.current) ||
+          actionableStructuredQuestion(stateRef.current)
             ? 'prompt'
             : runningStructuredAgentSessionTurnId(stateRef.current)
               ? 'working'