Fix chat stop and processing reconciliation (#415)

* fix(claude): await interrupt acknowledgements

* fix(queue): settle interrupted turns before draining

Closes #388

* test(queue): cover send now settlement lifecycle

Strengthens coverage for #388

* fix(agents): hand off active input at delivery boundary

Prevents stale predecessor restoration during active-input admission.

* fix(codex): transfer runtime metadata on active input

* fix(queue): hand off active input attempt ownership

* fix(codex): commit active input ownership atomically

Persist accepted input before publishing successor turn ownership across the queue, event bus, operation tracker, and Codex runtime. Transfer abortability at the same synchronous boundary and cover failure, restart, and settlement races deterministically.

* refactor(codex): preserve runtime architecture budget

* fix(claude): correlate interrupt acknowledgements

* fix(chats): reconcile stop outcomes and processing phases

* fix(claude): settle interrupts when turns finish first

* fix(chats): classify and diagnose stop settlement races

* fix(web): validate stop response outcomes

* fix(web): reconcile chat processing at the root

* fix(claude): accept tool abort terminal results

* fix(chats): publish resolved stop state before outcomes

* fix(claude): propagate interrupt transport failures

* fix(chats): reconcile processing snapshots by source

* fix(chats): enforce stop reconciliation outcomes

* test(claude): verify live interrupt protocol outcomes

* test(integration): fail closed on persisted credentials

* test(claude): accept UUID-less abort results

* test(codex): isolate live API credentials

* test(claude): allow SDK abort terminal variants

---------

Co-authored-by: yongkangc <chiayongtcac@gmail.com>

Author: cfal

.github/workflows/integration-tests.yml

@@ -98,8 +98,35 @@ jobs:
           ANTHROPIC_TESTING_KEY: ${{ secrets.ANTHROPIC_TESTING_KEY }}
         run: bun run test:live:claude
 
+      - name: Verify Claude diagnostics contain no testing credential
+        id: claude-diagnostics-audit
+        if: always() && steps.anthropic-key.outputs.available == 'true'
+        shell: bash
+        env:
+          ANTHROPIC_TESTING_KEY: ${{ secrets.ANTHROPIC_TESTING_KEY }}
+        run: |
+          echo "::add-mask::$ANTHROPIC_TESTING_KEY"
+          if [ -d integration-tests/artifacts/server ]; then
+            set +e
+            grep --recursive --fixed-strings --files-with-matches \
+              -- "$ANTHROPIC_TESTING_KEY" integration-tests/artifacts/server >/dev/null 2>&1
+            audit_status=$?
+            set -e
+            if [ "$audit_status" -eq 0 ]; then
+              echo "safe=false" >> "$GITHUB_OUTPUT"
+              echo "::error::Live Claude diagnostics contain the testing credential and will not be uploaded."
+              exit 1
+            fi
+            if [ "$audit_status" -ne 1 ]; then
+              echo "safe=false" >> "$GITHUB_OUTPUT"
+              echo "::error::Live Claude diagnostics could not be audited and will not be uploaded."
+              exit 1
+            fi
+          fi
+          echo "safe=true" >> "$GITHUB_OUTPUT"
+
       - name: Upload live Claude diagnostics
-        if: failure() && steps.anthropic-key.outputs.available == 'true'
+        if: failure() && steps.anthropic-key.outputs.available == 'true' && steps.claude-diagnostics-audit.outputs.safe == 'true'
         uses: actions/upload-artifact@v4
         with:
           name: claude-live-integration-diagnostics
@@ -152,8 +179,35 @@ jobs:
           OPENAI_TESTING_KEY: ${{ secrets.OPENAI_TESTING_KEY }}
         run: bun run test:live:codex
 
+      - name: Verify Codex diagnostics contain no testing credential
+        id: codex-diagnostics-audit
+        if: always() && steps.openai-key.outputs.available == 'true'
+        shell: bash
+        env:
+          OPENAI_TESTING_KEY: ${{ secrets.OPENAI_TESTING_KEY }}
+        run: |
+          echo "::add-mask::$OPENAI_TESTING_KEY"
+          if [ -d integration-tests/artifacts/server ]; then
+            set +e
+            grep --recursive --fixed-strings --files-with-matches \
+              -- "$OPENAI_TESTING_KEY" integration-tests/artifacts/server >/dev/null 2>&1
+            audit_status=$?
+            set -e
+            if [ "$audit_status" -eq 0 ]; then
+              echo "safe=false" >> "$GITHUB_OUTPUT"
+              echo "::error::Live Codex diagnostics contain the testing credential and will not be uploaded."
+              exit 1
+            fi
+            if [ "$audit_status" -ne 1 ]; then
+              echo "safe=false" >> "$GITHUB_OUTPUT"
+              echo "::error::Live Codex diagnostics could not be audited and will not be uploaded."
+              exit 1
+            fi
+          fi
+          echo "safe=true" >> "$GITHUB_OUTPUT"
+
       - name: Upload live Codex diagnostics
-        if: failure() && steps.openai-key.outputs.available == 'true'
+        if: failure() && steps.openai-key.outputs.available == 'true' && steps.codex-diagnostics-audit.outputs.safe == 'true'
         uses: actions/upload-artifact@v4
         with:
           name: codex-live-integration-diagnostics

common/__tests__/chat-command-contracts.test.js

@@ -8,6 +8,11 @@ import {
   parseQueueEntryReplaceCommandRequest,
   parseStartChatCommandRequest,
 } from '../chat-command-contracts.ts';
+import {
+  CHAT_STOP_OUTCOMES,
+  isAbortAcknowledged,
+  isStopSatisfied,
+} from '../chat-types.ts';
 
 const CHAT_ID = '1783725900000000';
 const SOURCE_CHAT_ID = '1783725900000001';
@@ -17,6 +22,18 @@ function agentSettings(ownerId = 'claude') {
 }
 
 describe('chat command request parsers', () => {
+  it('classifies every Stop outcome by command satisfaction and provider acknowledgement', () => {
+    expect(CHAT_STOP_OUTCOMES.map((outcome) => ({
+      outcome,
+      satisfied: isStopSatisfied(outcome),
+      acknowledged: isAbortAcknowledged(outcome),
+    }))).toEqual([
+      { outcome: 'interrupt-requested', satisfied: true, acknowledged: true },
+      { outcome: 'already-idle', satisfied: true, acknowledged: false },
+      { outcome: 'failed', satisfied: false, acknowledged: false },
+    ]);
+  });
+
   it('normalizes start modes and tags once at the wire boundary', () => {
     const parsed = parseStartChatCommandRequest({
       clientRequestId: ' request-1 ',

common/chat-command-contracts.ts

@@ -14,6 +14,7 @@ import type { ChatListEntry } from './chat-list.js';
 import type { ErrorCode } from './error-codes.js';
 import { normalizeTags } from './tags.js';
 import { InvalidChatIdError, parseChatId } from './chat-id.js';
+import type { ChatStopOutcome } from './chat-types.js';
 
 export type CommandStatus = 'accepted' | 'duplicate';
 
@@ -244,7 +245,7 @@ export interface AgentStopCommandRequest {
 }
 
 export interface AgentStopResponse extends CommandAcceptedResponse {
-  stopped: boolean;
+  outcome: ChatStopOutcome;
   control: ChatExecutionControlState;
 }
 
@@ -255,7 +256,7 @@ export interface AgentInterruptAndSendCommandRequest {
 }
 
 export interface AgentInterruptAndSendResponse extends CommandAcceptedResponse {
-  stopped: boolean;
+  outcome: ChatStopOutcome;
   control: ChatExecutionControlState;
 }
 

common/chat-list.ts

@@ -1,6 +1,7 @@
 import type { ApiProtocol } from './api-providers.js';
 import type { PermissionMode, ThinkingMode } from './chat-modes.js';
 import type { AgentSettingsEnvelope } from './agent-integration.js';
+import type { ChatProcessingPhase } from './chat-types.js';
 
 export interface ChatListEntry {
   id: string;
@@ -29,6 +30,8 @@ export interface ChatListEntry {
   isPinned: boolean;
   isArchived: boolean;
   isActive: boolean;
+  isProcessing: boolean;
+  processingPhase: ChatProcessingPhase | null;
   isUnread: boolean;
 }
 

common/chat-types.ts

@@ -10,6 +10,27 @@ export interface ChatImage {
 
 export type UserMessageDeliveryStatus = 'submitting' | 'accepted' | 'unconfirmed' | 'failed';
 export type ChatStopIntent = 'stop' | 'interrupt-and-send' | 'chat-deletion';
+export const CHAT_STOP_OUTCOMES = [
+  'interrupt-requested',
+  'already-idle',
+  'failed',
+] as const;
+export type ChatStopOutcome = typeof CHAT_STOP_OUTCOMES[number];
+export const CHAT_PROCESSING_PHASES = ['running', 'stopping'] as const;
+export type ChatProcessingPhase = typeof CHAT_PROCESSING_PHASES[number];
+
+export interface ChatProcessingEntry {
+  chatId: string;
+  phase: ChatProcessingPhase;
+}
+
+export function isStopSatisfied(outcome: ChatStopOutcome): boolean {
+  return outcome !== 'failed';
+}
+
+export function isAbortAcknowledged(outcome: ChatStopOutcome): boolean {
+  return outcome === 'interrupt-requested';
+}
 
 export interface ChatMessageMetadata {
   clientRequestId?: string;

common/ws-events.ts

@@ -1,6 +1,14 @@
 import type { ChatGenerationResetReason, ChatViewMessage } from './chat-view';
 import { parseChatViewMessages } from './chat-view';
-import type { ChatStopIntent, UserMessageDeliveryStatus } from './chat-types';
+import {
+  CHAT_STOP_OUTCOMES,
+  CHAT_PROCESSING_PHASES,
+  type ChatProcessingEntry,
+  type ChatProcessingPhase,
+  type ChatStopIntent,
+  type ChatStopOutcome,
+  type UserMessageDeliveryStatus,
+} from './chat-types';
 import type {
   PendingUserInput,
   PendingUserInputClearReason,
@@ -120,7 +128,7 @@ export class ChatSessionStoppedMessage {
   readonly type = 'chat-session-stopped' as const;
   constructor(
     public chatId: string,
-    public success: boolean,
+    public outcome: ChatStopOutcome,
     public intent: ChatStopIntent,
   ) {}
 }
@@ -129,7 +137,7 @@ export class ChatProcessingUpdatedMessage {
   readonly type = 'chat-processing-updated' as const;
   constructor(
     public chatId: string,
-    public isProcessing: boolean,
+    public phase: ChatProcessingPhase | null,
   ) {}
 }
 
@@ -155,14 +163,14 @@ export type ReconnectControlResult =
   | { chatId: string; outcome: 'not-found' }
   | { chatId: string; outcome: 'unavailable' };
 
-export type ReconnectProcessingResult =
-  | { outcome: 'snapshot'; runningChatIds: string[] }
+export type ChatProcessingSnapshotResult =
+  | { outcome: 'snapshot'; chats: ChatProcessingEntry[] }
   | { outcome: 'unavailable' };
 
 export class ReconnectStateMessage {
   readonly type = 'reconnect-state' as const;
   constructor(
-    public processing: ReconnectProcessingResult,
+    public processing: ChatProcessingSnapshotResult,
     public controlResults: ReconnectControlResult[],
     public clientRequestId?: string,
   ) {}
@@ -202,6 +210,7 @@ export class WsPongMessage {
     public clientRequestId: string,
     public sentAt: number,
     public serverTime: string,
+    public processing: ChatProcessingSnapshotResult,
   ) {}
 }
 
@@ -378,24 +387,26 @@ function reconnectControlResults(value: unknown): ReconnectControlResult[] | nul
   return results;
 }
 
-function reconnectProcessingResult(value: unknown): ReconnectProcessingResult | null {
+function chatProcessingSnapshotResult(value: unknown): ChatProcessingSnapshotResult | null {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
 
   const result = value as Record<string, unknown>;
   if (result.outcome === 'unavailable') return { outcome: 'unavailable' };
-  if (result.outcome !== 'snapshot' || !Array.isArray(result.runningChatIds)) return null;
+  if (result.outcome !== 'snapshot' || !Array.isArray(result.chats)) return null;
 
-  const runningChatIds: string[] = [];
+  const chats: ChatProcessingEntry[] = [];
   const seen = new Set<string>();
-  for (const valueChatId of result.runningChatIds) {
-    const chatId = requiredStr(valueChatId);
-    if (!chatId) return null;
-    if (seen.has(chatId)) continue;
+  for (const valueEntry of result.chats) {
+    if (!valueEntry || typeof valueEntry !== 'object' || Array.isArray(valueEntry)) return null;
+    const entry = valueEntry as Record<string, unknown>;
+    const chatId = requiredStr(entry.chatId);
+    const phase = CHAT_PROCESSING_PHASES.find((valuePhase) => valuePhase === entry.phase);
+    if (!chatId || !phase || seen.has(chatId)) return null;
     seen.add(chatId);
-    runningChatIds.push(chatId);
+    chats.push({ chatId, phase });
   }
 
-  return { outcome: 'snapshot', runningChatIds };
+  return { outcome: 'snapshot', chats };
 }
 
 function hasField(data: Record<string, unknown>, key: string): boolean {
@@ -584,18 +595,22 @@ export function parseServerWsMessage(
     case 'chat-session-stopped': {
       const chatId = requiredStr(data.chatId);
       const intent = data.intent;
+      const outcome = CHAT_STOP_OUTCOMES.find((entry) => entry === data.outcome);
       return chatId && (
         intent === 'stop'
         || intent === 'interrupt-and-send'
         || intent === 'chat-deletion'
-      )
-        ? new ChatSessionStoppedMessage(chatId, Boolean(data.success), intent)
+      ) && outcome
+        ? new ChatSessionStoppedMessage(chatId, outcome, intent)
         : null;
     }
     case 'chat-processing-updated': {
       const chatId = requiredStr(data.chatId);
-      return chatId
-        ? new ChatProcessingUpdatedMessage(chatId, Boolean(data.isProcessing))
+      const phase = data.phase === null
+        ? null
+        : CHAT_PROCESSING_PHASES.find((entry) => entry === data.phase);
+      return chatId && phase !== undefined
+        ? new ChatProcessingUpdatedMessage(chatId, phase)
         : null;
     }
     case 'chat-execution-control-updated': {
@@ -617,7 +632,7 @@ export function parseServerWsMessage(
         : null;
     }
     case 'reconnect-state': {
-      const processing = reconnectProcessingResult(data.processing);
+      const processing = chatProcessingSnapshotResult(data.processing);
       const controlResults = reconnectControlResults(data.controlResults);
       if (!processing || !controlResults) return null;
       return new ReconnectStateMessage(
@@ -664,8 +679,9 @@ export function parseServerWsMessage(
           ? data.sentAt
           : null;
       const serverTime = requiredStr(data.serverTime);
-      return clientRequestId && sentAt !== null && serverTime
-        ? new WsPongMessage(clientRequestId, sentAt, serverTime)
+      const processing = chatProcessingSnapshotResult(data.processing);
+      return clientRequestId && sentAt !== null && serverTime && processing
+        ? new WsPongMessage(clientRequestId, sentAt, serverTime, processing)
         : null;
     }
     case 'chat-title-updated': {