Codeman/test/session-submit-verifier.test.ts

/**
 * @fileoverview A prompt sent through the input route must actually leave the composer.
 *
 * Claude Code 2.1.277 ignores Enter for the first 30 to 50 seconds after the composer
 * paints while still taking typed text, so text+Enter 50 ms apart left every
 * programmatic prompt sitting unsent (measured 2026-09-19). These pin the recovery:
 * the verifier reads the last glyph line, re-sends Enter only while the prompt is
 * verifiably still there, stops the moment it is gone, never acts on a pane with no
 * composer, is capped, and is cancelled by a newer write or teardown.
 *
 * The browser's composers send a paste and a bare Enter as two writes, which used to arm
 * nothing; the second half pins the pairing, through a real Session on both transports.
 */
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import {
  SubmitVerifier,
  promptStillInComposer,
  SUBMIT_VERIFY_DELAYS_MS,
  bracketedPasteText,
  PastedPromptWatch,
  PASTE_ENTER_WINDOW_MS,
} from '../src/session-submit-verifier.js';
import { Session } from '../src/session.js';

const PROMPT =
  'Read /home/arkon/.codeman/pr-bot/jobs/pr-439/brief.md and carry out the review it describes. Do not ask questions.';

/** Measured 2026-09-19: typed, wrapped, a no-break space after the glyph, never sent. */
const STRANDED = [
  ' ▐▛███▛█   Claude Code v2.1.278',
  '──────────────────────────────────────── prbot-439 ─',
  '❯ Read /home/arkon/.codeman/pr-bot/jobs/pr-439/brief.md and carry out the review it describes. Do not ask',
  '  questions.',
  '────────────────────────────────────────────────────',
  '  Opus 5 (1M context)  in:0 out:0',
  '  ⏵⏵ bypass permissions on (shift+tab to cycle)',
].join('\n');

/** The same pane once taken: echoed in the transcript, composer empty. */
const TAKEN = [
  '❯ Read /home/arkon/.codeman/pr-bot/jobs/pr-439/brief.md and carry out the review it describes.',
  '● Reading the brief.',
  '✻ Actioning… (48s · ↓ 6.6k tokens)',
  '──────────────────────────────────────── prbot-439 ─',
  '❯',
  '────────────────────────────────────────────────────',
  '  Opus 5 (1M context)  in:192,963 out:371  ctx:19%',
].join('\n');

describe('promptStillInComposer', () => {
  it('sees the prompt sitting in the composer, no-break space and wrapping included', () => {
    expect(promptStillInComposer(STRANDED, PROMPT, '❯')).toBe(true);
  });
  it('is not fooled by the transcript echo once the composer is empty', () => {
    expect(promptStillInComposer(TAKEN, PROMPT, '❯')).toBe(false);
  });
  it('treats other text in the composer as not ours', () => {
    expect(promptStillInComposer(STRANDED, 'Summarise the changelog', '❯')).toBe(false);
  });
  it('answers undefined for a pane with no composer line, or no glyph', () => {
    expect(promptStillInComposer('$ ls\nfoo bar\n$ ', PROMPT, '❯')).toBeUndefined();
    expect(promptStillInComposer(STRANDED, PROMPT, '')).toBeUndefined();
  });
  it('honours the CLI glyph (Codex draws ›)', () => {
    expect(promptStillInComposer('› Reply with PONG\n', 'Reply with PONG', '›')).toBe(true);
    expect(promptStillInComposer('›\n', 'Reply with PONG', '›')).toBe(false);
  });
  it('reads through ANSI colour codes', () => {
    expect(promptStillInComposer('\x1b[1m❯\x1b[0m \x1b[36mReply with PONG\x1b[0m', 'Reply with PONG', '❯')).toBe(true);
  });
});

describe('SubmitVerifier', () => {
  let screen: string;
  let sends: number;
  let logs: string[];
  const make = (delaysMs?: readonly number[]) =>
    new SubmitVerifier({
      capture: () => screen,
      sendEnter: () => {
        sends++;
      },
      glyph: () => '❯',
      log: (m) => logs.push(m),
      delaysMs,
    });

  beforeEach(() => {
    vi.useFakeTimers();
    screen = STRANDED;
    sends = 0;
    logs = [];
  });
  afterEach(() => {
    vi.useRealTimers();
  });

  it('re-sends Enter while the prompt is still there and stops once it is taken', async () => {
    const v = make([1_000, 1_000, 1_000, 1_000]);
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(sends).toBe(1);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(sends).toBe(2);
    screen = TAKEN; // Claude Code finally honoured one
    await vi.advanceTimersByTimeAsync(5_000);
    expect(sends).toBe(2);
    expect(logs[0]).toContain('still in the composer after 1s');
    expect(logs[1]).toContain('(2/4)');
  });

  it('costs one capture and no Enter when the prompt was taken on the first try', async () => {
    let captures = 0;
    const v = new SubmitVerifier({
      capture: () => {
        captures++;
        return TAKEN;
      },
      sendEnter: () => {
        sends++;
      },
      glyph: () => '❯',
    });
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(120_000);
    expect(captures).toBe(1);
    expect(sends).toBe(0);
  });

  it('never presses Enter into a pane with no composer line', async () => {
    screen = '$ npm test\n... running ...\n';
    const v = make([1_000, 1_000]);
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(10_000);
    expect(sends).toBe(0);
  });

  it('is capped at the schedule length when the prompt never leaves', async () => {
    const v = make();
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(10 * 60_000);
    expect(sends).toBe(SUBMIT_VERIFY_DELAYS_MS.length);
  });

  it('production schedule reaches past the measured window', () => {
    const total = SUBMIT_VERIFY_DELAYS_MS.reduce((a, b) => a + b, 0);
    expect(SUBMIT_VERIFY_DELAYS_MS[0]).toBeLessThanOrEqual(2_000);
    expect(total).toBeGreaterThanOrEqual(60_000);
  });

  it('a newer write replaces the schedule, so an old prompt never submits a new one', async () => {
    const v = make([1_000, 1_000, 1_000]);
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(sends).toBe(1);
    screen = '❯ Something the user typed next';
    v.arm('Something the user typed next');
    await vi.advanceTimersByTimeAsync(1_000);
    expect(sends).toBe(2); // for the NEW prompt, which is what the composer holds
    screen = '❯';
    await vi.advanceTimersByTimeAsync(5_000);
    expect(sends).toBe(2);
  });

  it('cancel() stops everything', async () => {
    const v = make([1_000, 1_000]);
    v.arm(PROMPT);
    v.cancel();
    await vi.advanceTimersByTimeAsync(10_000);
    expect(sends).toBe(0);
  });

  it('keeps checking when sendEnter throws', async () => {
    let calls = 0;
    const v = new SubmitVerifier({
      capture: () => screen,
      sendEnter: () => {
        calls++;
        throw new Error('tmux hiccup');
      },
      glyph: () => '❯',
      delaysMs: [1_000, 1_000],
    });
    v.arm(PROMPT);
    await vi.advanceTimersByTimeAsync(3_000);
    expect(calls).toBe(2);
  });
});

/** Composer chrome measured on Claude Code 2.1.303 (2026-10-19); the prompts are invented. */
const RULE = '────────────────────────────────────────────────────────────────';
const pane = (...composer: string[]) =>
  [
    ' ▐▛███▛█   Claude Code v2.1.303',
    RULE,
    ...composer,
    RULE,
    '  Opus 5.5  in:0 out:0',
    '  paste again to expand',
  ].join('\n');

describe('promptStillInComposer: what a pasted prompt looks like', () => {
  it('reads a short multi-line paste, shown inline, as the prompt', () => {
    const prompt = 'Fix it\rThen run the tests\rand commit';
    expect(promptStillInComposer(pane('❯\xa0Fix it', '  Then run the tests', '  and commit'), prompt, '❯')).toBe(true);
    expect(promptStillInComposer(pane('❯\xa0'), prompt, '❯')).toBe(false);
  });

  it('reads a long word wrapped off the first line', () => {
    const prompt = `Line 1 ${'x'.repeat(200)}`;
    expect(promptStillInComposer(pane('❯\xa0Line 1', `  ${'x'.repeat(118)}`, `  ${'x'.repeat(82)}`), prompt, '❯')).toBe(
      true
    );
  });

  it('counts the stand-in for a long paste only when its line count is the prompt’s', () => {
    const fourLines = 'a\rb\rc\rd';
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1 +3 lines]'), fourLines, '❯')).toBe(true);
    // `#n` counts pastes, so a later one is still ours.
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #4 +3 lines]'), fourLines, '❯')).toBe(true);
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1 +1 lines]'), fourLines, '❯')).toBe(false);
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1]'), fourLines, '❯')).toBe(false);
    const oneLong = 'y'.repeat(900);
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1]'), oneLong, '❯')).toBe(true);
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1 +3 lines]'), oneLong, '❯')).toBe(false);
  });

  it('never takes the stand-in plus typed text, or a dialog row, for the prompt', () => {
    expect(promptStillInComposer(pane('❯\xa0[Pasted text #1] and more'), 'y'.repeat(900), '❯')).toBe(false);
    // A short answer has to match whole: `1` is not the highlighted `1. Yes`.
    expect(promptStillInComposer(pane('❯ 1. Yes', '  2. No'), '1', '❯')).toBe(false);
    expect(promptStillInComposer(pane('❯ yes please'), 'yes', '❯')).toBe(false);
    expect(promptStillInComposer(pane('❯ yes'), 'yes', '❯')).toBe(true);
  });
});

describe('bracketedPasteText', () => {
  it('returns the text of exactly one paste and nothing else', () => {
    expect(bracketedPasteText('\x1b[200~hello\rworld\x1b[201~')).toBe('hello\rworld');
    expect(bracketedPasteText('hello\r')).toBeNull();
    expect(bracketedPasteText('\x1b[200~hello\x1b[201~\r')).toBeNull();
    expect(bracketedPasteText('\x1b[200~a\x1b[201~\x1b[200~b\x1b[201~')).toBeNull();
    expect(bracketedPasteText('\x1b[200~')).toBeNull();
  });
});

describe('PastedPromptWatch', () => {
  const paste = (t: string) => `\x1b[200~${t}\x1b[201~`;

  it('pairs a paste with the bare Enter right after it', () => {
    const w = new PastedPromptWatch();
    expect(w.feed(paste('Reply with ready'), 0)).toEqual({ kind: 'paste' });
    expect(w.feed('\r', 120)).toEqual({ kind: 'submit', text: 'Reply with ready' });
    // Spent: a second Enter submits nothing of ours.
    expect(w.feed('\r', 200)).toBeNull();
  });

  it('lets nothing come between the two, and nothing arrive late', () => {
    const w = new PastedPromptWatch();
    w.feed(paste('one'), 0);
    expect(w.feed('x', 50)).toBeNull();
    expect(w.feed('\r', 100)).toBeNull();
    w.feed(paste('two'), 1_000);
    expect(w.feed('\r', 1_000 + PASTE_ENTER_WINDOW_MS + 1)).toBeNull();
  });

  it('ignores an Enter with no paste before it, and an empty paste', () => {
    const w = new PastedPromptWatch();
    expect(w.feed('\r', 0)).toBeNull();
    expect(w.feed(paste('  '), 10)).toEqual({ kind: 'paste' });
    expect(w.feed('\r', 20)).toBeNull();
  });
});

describe('Session: a composer send is checked like any other prompt', () => {
  const STRANDED_PASTE = pane('❯\xa0Reply with only the word ready.');
  const EMPTY = pane('❯\xa0');
  let screen: string;
  let muxEnters: number;

  /** A session with a scripted pane, a recording mux and a PTY that swallows writes. */
  function makeSession(): Session {
    const mux = {
      isAvailable: () => true,
      capturePaneText: () => screen,
      sendInput: async (_id: string, input: string) => {
        if (input === '\r') muxEnters++;
        return true;
      },
    } as unknown as NonNullable<ConstructorParameters<typeof Session>[0]>['mux'];
    const session = new Session({
      workingDir: '/tmp',
      mode: 'claude',
      mux,
      muxSession: { muxName: 'codeman-test', sessionId: 'test', createdAt: Date.now() },
    } as ConstructorParameters<typeof Session>[0]);
    (session as unknown as { ptyProcess: { write: (d: string) => void } }).ptyProcess = { write: () => {} };
    return session;
  }

  beforeEach(() => {
    vi.useFakeTimers();
    screen = STRANDED_PASTE;
    muxEnters = 0;
  });
  afterEach(() => {
    vi.useRealTimers();
  });

  it('WebSocket: paste then Enter, both raw writes, re-presses Enter until the prompt leaves', async () => {
    const session = makeSession();
    session.write('\x1b[200~Reply with only the word ready.\x1b[201~', { fromUser: true });
    session.write('\r', { fromUser: true });
    await vi.advanceTimersByTimeAsync(2_000);
    expect(muxEnters).toBe(1);
    screen = EMPTY;
    await vi.advanceTimersByTimeAsync(120_000);
    expect(muxEnters).toBe(1);
  });

  it('POST fallback: the Enter goes through writeViaMux and arms the same check', async () => {
    const session = makeSession();
    session.write('\x1b[200~Reply with only the word ready.\x1b[201~', { fromUser: true });
    await session.writeViaMux('\r', { fromUser: true });
    expect(muxEnters).toBe(1); // the Enter itself
    await vi.advanceTimersByTimeAsync(2_000);
    expect(muxEnters).toBe(2);
  });

  it('a taken prompt costs nothing more', async () => {
    screen = EMPTY;
    const session = makeSession();
    session.write('\x1b[200~Reply with only the word ready.\x1b[201~', { fromUser: true });
    session.write('\r', { fromUser: true });
    await vi.advanceTimersByTimeAsync(120_000);
    expect(muxEnters).toBe(0);
  });

  it('a newer paste cancels the check, so Enter never sends the user’s own paste', async () => {
    const session = makeSession();
    session.write(`\x1b[200~${'y'.repeat(900)}\x1b[201~`, { fromUser: true });
    session.write('\r', { fromUser: true });
    // Taken; then the user pastes something long of their own into the terminal.
    session.write(`\x1b[200~${'z'.repeat(900)}\x1b[201~`, { fromUser: true });
    screen = pane('❯\xa0[Pasted text #2]');
    await vi.advanceTimersByTimeAsync(120_000);
    expect(muxEnters).toBe(0);
  });

  it('typing in the terminal arms nothing', async () => {
    screen = pane('❯\xa0hi');
    const session = makeSession();
    for (const key of ['h', 'i', '\r']) session.write(key, { fromUser: true });
    await vi.advanceTimersByTimeAsync(120_000);
    expect(muxEnters).toBe(0);
  });
});