fix(chats): enforce stop reconciliation outcomes

Author: cfal

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 ',

integration-tests/support/fake-claude-cli.ts

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import {
   accessSync,
   appendFileSync,
+  existsSync,
   mkdirSync,
   writeFileSync,
 } from 'node:fs';
@@ -10,6 +11,11 @@ import { join, resolve } from 'node:path';
 
 const MAX_SANITIZED_LENGTH = 200;
 const args = process.argv.slice(2);
+let heldInput: {
+  uuid: string;
+  sessionId: string;
+} | null = null;
+let heldAbortPoll: ReturnType<typeof setInterval> | null = null;
 
 if (args.includes('--version')) {
   console.log('2.1.220 (Claude Code)');
@@ -119,6 +125,20 @@ function handleInput(line: string, nativePath: string, sessionId: string): void
     uuid?: string;
     message?: { role?: string; content?: unknown };
   };
+  if (input.type === 'control_request' && input.request?.subtype === 'interrupt') {
+    writeOutput({
+      type: 'control_response',
+      response: {
+        subtype: 'success',
+        request_id: input.request_id,
+        response: { cancelled: [], still_queued: [] },
+      },
+    });
+    const interruptPath = process.env.CLAUDE_TEST_INTERRUPT_PATH;
+    if (interruptPath) appendFileSync(interruptPath, 'interrupt\n');
+    scheduleHeldAbortSettlement();
+    return;
+  }
   if (
     input.type === 'control_request'
     && (input.request?.subtype === 'initialize' || input.request?.subtype === 'set_model')
@@ -140,6 +160,45 @@ function handleInput(line: string, nativePath: string, sessionId: string): void
   const response = `echo:${prompt}`;
   const userTimestamp = new Date().toISOString();
   const assistantTimestamp = new Date(Date.now() + 1).toISOString();
+  if (process.env.CLAUDE_TEST_HOLD_ACTIVE === '1') {
+    appendFileSync(nativePath, `${JSON.stringify({
+      sessionId,
+      type: 'user',
+      uuid: input.uuid,
+      timestamp: userTimestamp,
+      cwd: process.cwd(),
+      message: { role: 'user', content: prompt },
+    })}\n`);
+    writeOutput({
+      type: 'command_lifecycle',
+      command_uuid: input.uuid,
+      state: 'queued',
+      session_id: sessionId,
+    });
+    writeOutput({
+      type: 'system',
+      subtype: 'session_state_changed',
+      state: 'running',
+      session_id: sessionId,
+    });
+    writeOutput({
+      type: 'command_lifecycle',
+      command_uuid: input.uuid,
+      state: 'started',
+      session_id: sessionId,
+    });
+    writeOutput({
+      type: 'user',
+      uuid: input.uuid,
+      isReplay: true,
+      message: input.message,
+      session_id: sessionId,
+    });
+    heldInput = { uuid: input.uuid, sessionId };
+    const startedPath = process.env.CLAUDE_TEST_STARTED_PATH;
+    if (startedPath) writeFileSync(startedPath, `${input.uuid}\n`);
+    return;
+  }
   appendFileSync(nativePath, [
     JSON.stringify({
       sessionId,
@@ -219,6 +278,42 @@ function handleInput(line: string, nativePath: string, sessionId: string): void
   });
 }
 
+function scheduleHeldAbortSettlement(): void {
+  if (!heldInput || heldAbortPoll) return;
+  const releasePath = process.env.CLAUDE_TEST_RELEASE_PATH;
+  if (!releasePath) return;
+  heldAbortPoll = setInterval(() => {
+    if (!heldInput || !existsSync(releasePath)) return;
+    const input = heldInput;
+    heldInput = null;
+    if (heldAbortPoll) clearInterval(heldAbortPoll);
+    heldAbortPoll = null;
+    writeOutput({
+      type: 'result',
+      subtype: 'error_during_execution',
+      terminal_reason: 'aborted_tools',
+      is_error: true,
+      duration_ms: 1,
+      num_turns: 1,
+      result: '',
+      user_message_uuid: input.uuid,
+      session_id: input.sessionId,
+    });
+    writeOutput({
+      type: 'command_lifecycle',
+      command_uuid: input.uuid,
+      state: 'cancelled',
+      session_id: input.sessionId,
+    });
+    writeOutput({
+      type: 'system',
+      subtype: 'session_state_changed',
+      state: 'idle',
+      session_id: input.sessionId,
+    });
+  }, 5);
+}
+
 function messageText(content: unknown): string {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';

integration-tests/support/integration-fixture.ts

@@ -306,7 +306,7 @@ export class IntegrationFixture {
     clientRequestId?: string;
     turnId?: string;
   }): Promise<void> {
-    const nativePath = await this.#directOpenAiNativePath(input.chatId);
+    const nativePath = await this.directOpenAiNativePath(input.chatId);
     const raw = await readFile(nativePath, 'utf8');
     if (raw.length > 0 && !raw.endsWith('\n')) {
       throw new Error('Direct native transcript has an incomplete tail.');
@@ -320,7 +320,7 @@ export class IntegrationFixture {
     })}\n`, 'utf8');
   }
 
-  async #directOpenAiNativePath(chatId: string): Promise<string> {
+  async directOpenAiNativePath(chatId: string): Promise<string> {
     const registry = JSON.parse(
       await readFile(join(this.dirs.workspace, 'chats.json'), 'utf8'),
     ) as { sessions?: Record<string, Record<string, unknown>> };
@@ -358,7 +358,7 @@ export class IntegrationFixture {
   }
 
   async #removeFinalNativeUserRow(input: { chatId: string; clientRequestId: string }): Promise<void> {
-    const expectedPath = await this.#directOpenAiNativePath(input.chatId);
+    const expectedPath = await this.directOpenAiNativePath(input.chatId);
     const raw = await readFile(expectedPath, 'utf8');
     if (!raw.endsWith('\n')) throw new Error('Direct native transcript has an incomplete tail.');
     const lines = raw.split('\n').filter((line) => line.length > 0);