github-issue-tower-defence-management 2.19.0 → 2.19.2

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.test.ts

@@ -1,253 +0,0 @@
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { Sleeper } from '../../domain/usecases/adapter-interfaces/Sleeper';
-import { TmuxSilentSessionNotificationRepository } from './TmuxSilentSessionNotificationRepository';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
-
-const createMockRunner = (): Mocked<LocalCommandRunner> => ({
-  runCommand: jest.fn().mockResolvedValue({
-    stdout: '',
-    stderr: '',
-    exitCode: 0,
-  }),
-  spawnInteractive: jest.fn(),
-});
-
-const createMockSleeper = (): Mocked<Sleeper> => ({
-  sleep: jest.fn().mockResolvedValue(undefined),
-});
-
-const sessionName = 'https_//github_com/owner/repo/issues/9';
-
-const paneWithInputBoxContent = (inputBoxContent: string): string =>
-  [
-    '● The previous assistant output line',
-    '',
-    '────────────────────────────────────────',
-    inputBoxContent,
-    '────────────────────────────────────────',
-    '  {Opus 4.5} (dev1)  CTX[██░░░░░░░░]16%',
-  ].join('\n');
-
-const createPaneAwareRunner = (
-  paneTexts: string[],
-): Mocked<LocalCommandRunner> => {
-  let capturedPaneIndex = 0;
-  return {
-    runCommand: jest.fn().mockImplementation((_program, args: string[]) => {
-      if (args[0] !== 'capture-pane') {
-        return Promise.resolve({ stdout: '', stderr: '', exitCode: 0 });
-      }
-      const paneText =
-        paneTexts[Math.min(capturedPaneIndex, paneTexts.length - 1)];
-      capturedPaneIndex += 1;
-      return Promise.resolve({ stdout: paneText, stderr: '', exitCode: 0 });
-    }),
-    spawnInteractive: jest.fn(),
-  };
-};
-
-const submitKeyCallCount = (runner: Mocked<LocalCommandRunner>): number =>
-  runner.runCommand.mock.calls.filter(
-    (call) => call[1][0] === 'send-keys' && call[1][3] === 'Enter',
-  ).length;
-
-describe('TmuxSilentSessionNotificationRepository', () => {
-  describe('sendSelfCheckNotification', () => {
-    it('wraps the message in bracketed-paste framing, sends it literally, then submits it with Enter', async () => {
-      const runner = createMockRunner();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        'self check message',
-      );
-
-      expect(runner.runCommand.mock.calls[0]).toEqual([
-        'tmux',
-        [
-          'send-keys',
-          '-t',
-          sessionName,
-          '-l',
-          '\x1b[200~self check message\x1b[201~',
-        ],
-      ]);
-      expect(runner.runCommand.mock.calls[1]).toEqual([
-        'tmux',
-        ['send-keys', '-t', sessionName, 'Enter'],
-      ]);
-    });
-
-    it('flattens a multi-line message into a single line so no newline reaches the input box', async () => {
-      const runner = createMockRunner();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-      const multiLineMessage = 'first line\nsecond line\n\nthird line';
-
-      await repository.sendSelfCheckNotification(sessionName, multiLineMessage);
-
-      const literalArgument = runner.runCommand.mock.calls[0][1][4];
-      expect(literalArgument).not.toContain('\n');
-      expect(literalArgument).not.toContain('\r');
-      expect(
-        literalArgument.slice('\x1b[200~'.length, -'\x1b[201~'.length),
-      ).toBe('first line second line third line');
-    });
-
-    it('keeps the bracketed-paste framing around the flattened message', async () => {
-      const runner = createMockRunner();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        'first line\nsecond line',
-      );
-
-      const literalArgument = runner.runCommand.mock.calls[0][1][4];
-      const literalBytes = Buffer.from(literalArgument, 'utf8').toString('hex');
-      expect(literalBytes.startsWith('1b5b3230307e')).toBe(true);
-      expect(literalBytes.endsWith('1b5b3230317e')).toBe(true);
-      expect(runner.runCommand.mock.calls[1]).toEqual([
-        'tmux',
-        ['send-keys', '-t', sessionName, 'Enter'],
-      ]);
-    });
-
-    it('collapses the run of spaces left by consecutive line breaks', async () => {
-      const runner = createMockRunner();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        'section one\n\n\nsection two',
-      );
-
-      const literalArgument = runner.runCommand.mock.calls[0][1][4];
-      expect(
-        literalArgument.slice('\x1b[200~'.length, -'\x1b[201~'.length),
-      ).toBe('section one section two');
-    });
-
-    it('throws when sending the message literally fails', async () => {
-      const runner = createMockRunner();
-      runner.runCommand.mockResolvedValueOnce({
-        stdout: '',
-        stderr: "can't find session",
-        exitCode: 1,
-      });
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await expect(
-        repository.sendSelfCheckNotification('missing_session', 'message'),
-      ).rejects.toThrow(
-        'Failed to send notification to tmux session "missing_session"',
-      );
-    });
-
-    it('pushes the message out with another Enter while it is still sitting in the input box', async () => {
-      const runner = createPaneAwareRunner([
-        paneWithInputBoxContent(
-          '❯ [TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-        ),
-        paneWithInputBoxContent('❯ '),
-      ]);
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        '[TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-      );
-
-      expect(submitKeyCallCount(runner)).toBe(2);
-      expect(runner.runCommand.mock.calls[2]).toEqual([
-        'tmux',
-        ['capture-pane', '-p', '-t', sessionName],
-      ]);
-    });
-
-    it('sends no further Enter once the input box no longer holds the message', async () => {
-      const runner = createPaneAwareRunner([paneWithInputBoxContent('❯ ')]);
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        '[TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-      );
-
-      expect(submitKeyCallCount(runner)).toBe(1);
-    });
-
-    it('sends no further Enter while the message is held as a queued message', async () => {
-      const runner = createPaneAwareRunner([
-        paneWithInputBoxContent('❯ Press up to edit queued messages'),
-      ]);
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        '[TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-      );
-
-      expect(submitKeyCallCount(runner)).toBe(1);
-    });
-
-    it('stops pushing after the configured attempt limit so newlines cannot pile up', async () => {
-      const runner = createPaneAwareRunner([
-        paneWithInputBoxContent(
-          '❯ [TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-        ),
-      ]);
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        createMockSleeper(),
-        2,
-      );
-
-      await repository.sendSelfCheckNotification(
-        sessionName,
-        '[TDPM_SILENT_SESSION_SELF_CHECK_REMINDER] report your state',
-      );
-
-      expect(submitKeyCallCount(runner)).toBe(3);
-    });
-
-    it('waits for the bracketed-paste parsing and rendering window before reading the input box back', async () => {
-      const runner = createPaneAwareRunner([paneWithInputBoxContent('❯ ')]);
-      const sleeper = createMockSleeper();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        sleeper,
-        3,
-        2500,
-      );
-
-      await repository.sendSelfCheckNotification(sessionName, 'self check');
-
-      expect(sleeper.sleep).toHaveBeenCalledWith(2500);
-    });
-  });
-});

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts

@@ -1,158 +0,0 @@
-import { SilentSessionNotificationRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotificationRepository';
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { Sleeper } from '../../domain/usecases/adapter-interfaces/Sleeper';
-
-const BRACKETED_PASTE_START = '\x1b[200~';
-const BRACKETED_PASTE_END = '\x1b[201~';
-
-export const DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT = 3;
-export const DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS = 2500;
-
-const INPUT_BOX_BORDER_LINE_PATTERN = /^[\s─━╌┄┈│╭╮╰╯]+$/u;
-const INPUT_PROMPT_PREFIX_PATTERN = /^[\s>❯│]+/u;
-const INPUT_BOX_MESSAGE_PROBE_LENGTH = 24;
-
-type InputBoxState = 'holdsMessage' | 'clearedMessage' | 'unreadable';
-
-const withoutWhitespace = (value: string): string => value.replace(/\s+/gu, '');
-
-export const extractTmuxInputBoxContent = (paneText: string): string | null => {
-  const lines = paneText.split('\n');
-  const borderLineIndexes = lines.flatMap((line, index) =>
-    line.trim().length > 0 && INPUT_BOX_BORDER_LINE_PATTERN.test(line)
-      ? [index]
-      : [],
-  );
-  if (borderLineIndexes.length < 2) {
-    return null;
-  }
-  const closingBorderIndex = borderLineIndexes[borderLineIndexes.length - 1];
-  const openingBorderIndex = borderLineIndexes[borderLineIndexes.length - 2];
-  return lines
-    .slice(openingBorderIndex + 1, closingBorderIndex)
-    .map((line) => line.replace(INPUT_PROMPT_PREFIX_PATTERN, ''))
-    .join('');
-};
-
-export const resolveInputBoxStateFromPane = (
-  paneText: string,
-  singleLineMessage: string,
-): InputBoxState => {
-  const inputBoxContent = extractTmuxInputBoxContent(paneText);
-  if (inputBoxContent === null) {
-    return 'unreadable';
-  }
-  const messageProbe = withoutWhitespace(singleLineMessage).slice(
-    0,
-    INPUT_BOX_MESSAGE_PROBE_LENGTH,
-  );
-  if (messageProbe.length === 0) {
-    return 'clearedMessage';
-  }
-  return withoutWhitespace(inputBoxContent).includes(messageProbe)
-    ? 'holdsMessage'
-    : 'clearedMessage';
-};
-
-export class TmuxSilentSessionNotificationRepository implements SilentSessionNotificationRepository {
-  constructor(
-    private readonly localCommandRunner: LocalCommandRunner,
-    private readonly sleeper: Sleeper,
-    private readonly submitPushOutAttemptLimit: number = DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT,
-    private readonly submitPushOutWaitMilliseconds: number = DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS,
-  ) {}
-
-  sendSelfCheckNotification = async (
-    sessionName: string,
-    message: string,
-  ): Promise<void> => {
-    const singleLineMessage = message.replace(/\s*[\r\n]+\s*/g, ' ').trim();
-    const framedMessage = `${BRACKETED_PASTE_START}${singleLineMessage}${BRACKETED_PASTE_END}`;
-    const literalResult = await this.localCommandRunner.runCommand('tmux', [
-      'send-keys',
-      '-t',
-      sessionName,
-      '-l',
-      framedMessage,
-    ]);
-    if (literalResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to send notification to tmux session "${sessionName}": exit code ${literalResult.exitCode}${
-          literalResult.stderr ? `: ${literalResult.stderr}` : ''
-        }`,
-      );
-    }
-    await this.submitInputBox(sessionName);
-    await this.pushOutUnsubmittedMessage(sessionName, singleLineMessage);
-  };
-
-  private submitInputBox = async (sessionName: string): Promise<void> => {
-    const submitResult = await this.localCommandRunner.runCommand('tmux', [
-      'send-keys',
-      '-t',
-      sessionName,
-      'Enter',
-    ]);
-    if (submitResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to send notification to tmux session "${sessionName}": exit code ${submitResult.exitCode}${
-          submitResult.stderr ? `: ${submitResult.stderr}` : ''
-        }`,
-      );
-    }
-  };
-
-  private pushOutUnsubmittedMessage = async (
-    sessionName: string,
-    singleLineMessage: string,
-  ): Promise<void> => {
-    for (
-      let attempt = 0;
-      attempt < this.submitPushOutAttemptLimit;
-      attempt += 1
-    ) {
-      await this.sleeper.sleep(this.submitPushOutWaitMilliseconds);
-      const inputBoxState = await this.readInputBoxState(
-        sessionName,
-        singleLineMessage,
-      );
-      if (inputBoxState === 'clearedMessage') {
-        return;
-      }
-      if (inputBoxState === 'unreadable') {
-        console.log(
-          `Could not read back the input box of tmux session "${sessionName}"; leaving the notification as sent without pushing it out.`,
-        );
-        return;
-      }
-      await this.submitInputBox(sessionName);
-    }
-    console.log(
-      `Notification to tmux session "${sessionName}" was still held in the input box after ${this.submitPushOutAttemptLimit} push-out attempt(s).`,
-    );
-  };
-
-  private readInputBoxState = async (
-    sessionName: string,
-    singleLineMessage: string,
-  ): Promise<InputBoxState> => {
-    const captureResult = await this.localCommandRunner.runCommand('tmux', [
-      'capture-pane',
-      '-p',
-      '-t',
-      sessionName,
-    ]);
-    if (captureResult.exitCode !== 0) {
-      console.log(
-        `Failed to capture the pane of tmux session "${sessionName}": exit code ${captureResult.exitCode}${
-          captureResult.stderr ? `: ${captureResult.stderr}` : ''
-        }`,
-      );
-      return 'unreadable';
-    }
-    return resolveInputBoxStateFromPane(
-      captureResult.stdout,
-      singleLineMessage,
-    );
-  };
-}

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.queuedReply.test.ts

@@ -1,171 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TranscriptOwnerCallStatusProvider } from './TranscriptOwnerCallStatusProvider';
-import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
-
-describe('TranscriptOwnerCallStatusProvider owner reply typed mid-turn', () => {
-  let rootDirectory: string;
-  let markerDirectory: string;
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'queued-reply-'));
-    markerDirectory = path.join(rootDirectory, 'markers');
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDirectory, { force: true, recursive: true });
-  });
-
-  const sessionId = 'e7a58bf9-4d13-4e27-b446-52c3b017ad79';
-  const callTimestamp = '2026-08-10T11:04:26.331Z';
-  const earlierReplyTimestamp = '2026-08-10T11:02:40.286Z';
-  const laterReplyTimestamp = '2026-08-10T11:05:53.576Z';
-
-  const writeTranscript = (lines: object[]): string => {
-    const filePath = path.join(rootDirectory, `${sessionId}.jsonl`);
-    fs.writeFileSync(
-      filePath,
-      lines.map((line) => JSON.stringify(line)).join('\n'),
-      'utf8',
-    );
-    return filePath;
-  };
-
-  const writeReplyMarker = (timestamp: string): void => {
-    fs.mkdirSync(markerDirectory, { recursive: true });
-    fs.writeFileSync(
-      path.join(markerDirectory, `${sessionId}.reply_ts`),
-      `${timestamp}\n`,
-      'utf8',
-    );
-  };
-
-  const ownerCall = (timestamp: string): object => ({
-    type: 'assistant',
-    timestamp,
-    message: {
-      role: 'assistant',
-      content: [{ type: 'text', text: 'Please decide <<OWNER_CALL>>' }],
-    },
-  });
-
-  const typedReply = (timestamp: string, text: string): object => ({
-    type: 'user',
-    timestamp,
-    promptSource: 'typed',
-    origin: { kind: 'human' },
-    message: { role: 'user', content: text },
-  });
-
-  const enqueued = (timestamp: string, content: string): object => ({
-    type: 'queue-operation',
-    operation: 'enqueue',
-    timestamp,
-    sessionId,
-    content,
-  });
-
-  const removed = (timestamp: string, content: string): object => ({
-    type: 'queue-operation',
-    operation: 'remove',
-    timestamp,
-    sessionId,
-    content,
-  });
-
-  const unansweredSecondsOf = async (
-    transcriptPath: string,
-    replyMarkerDirectory: string | null,
-  ): Promise<number | undefined> => {
-    const provider = new TranscriptOwnerCallStatusProvider(
-      '<<OWNER_CALL>>',
-      replyMarkerDirectory,
-    );
-    const result =
-      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
-        new Map([['session', transcriptPath]]),
-      );
-    return result.get('session');
-  };
-
-  it('treats a reply enqueued while the agent was working as an answer to the call', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-      enqueued(laterReplyTimestamp, 'CI が通っていないのに許可はできません'),
-      removed(
-        '2026-08-10T11:06:07.885Z',
-        'CI が通っていないのに許可はできません',
-      ),
-    ]);
-
-    expect(await unansweredSecondsOf(transcriptPath, null)).toBeUndefined();
-  });
-
-  it('keeps the call unanswered when the only later enqueue is a task notification', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-      enqueued(
-        laterReplyTimestamp,
-        '<task-notification><task-id>abc</task-id></task-notification>',
-      ),
-    ]);
-
-    expect(await unansweredSecondsOf(transcriptPath, null)).toBe(
-      Math.floor(Date.parse(callTimestamp) / 1000),
-    );
-  });
-
-  it('keeps the call unanswered when the only later enqueue is an injected reminder', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-      enqueued(
-        laterReplyTimestamp,
-        `${SILENT_SESSION_REMINDER_SENTINEL} check yourself`,
-      ),
-    ]);
-
-    expect(await unansweredSecondsOf(transcriptPath, null)).toBe(
-      Math.floor(Date.parse(callTimestamp) / 1000),
-    );
-  });
-
-  it('treats the reply time recorded by the status line marker as an answer to the call', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-    ]);
-    writeReplyMarker(laterReplyTimestamp);
-
-    expect(
-      await unansweredSecondsOf(transcriptPath, markerDirectory),
-    ).toBeUndefined();
-  });
-
-  it('keeps the call unanswered when the status line marker predates the call', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-    ]);
-    writeReplyMarker(earlierReplyTimestamp);
-
-    expect(await unansweredSecondsOf(transcriptPath, markerDirectory)).toBe(
-      Math.floor(Date.parse(callTimestamp) / 1000),
-    );
-  });
-
-  it('keeps the call unanswered when no marker file exists for the session', async () => {
-    const transcriptPath = writeTranscript([
-      typedReply(earlierReplyTimestamp, 'an earlier answer'),
-      ownerCall(callTimestamp),
-    ]);
-    fs.mkdirSync(markerDirectory, { recursive: true });
-
-    expect(await unansweredSecondsOf(transcriptPath, markerDirectory)).toBe(
-      Math.floor(Date.parse(callTimestamp) / 1000),
-    );
-  });
-});

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.singleScan.test.ts

@@ -1,86 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TranscriptOwnerCallStatusProvider } from './TranscriptOwnerCallStatusProvider';
-
-describe('TranscriptOwnerCallStatusProvider single transcript scan', () => {
-  let rootDirectory: string;
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'single-scan-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDirectory, { force: true, recursive: true });
-  });
-
-  const writeTranscript = (fileName: string, lines: object[]): string => {
-    const filePath = path.join(rootDirectory, fileName);
-    fs.writeFileSync(
-      filePath,
-      lines.map((line) => JSON.stringify(line)).join('\n'),
-      'utf8',
-    );
-    return filePath;
-  };
-
-  const assistantWithMarker = (timestamp: string): object => ({
-    type: 'assistant',
-    timestamp,
-    message: {
-      role: 'assistant',
-      stop_reason: 'end_turn',
-      content: [
-        { type: 'text', text: 'Waiting <<OWNER_CALL>> please decide.' },
-      ],
-    },
-  });
-
-  const epochSecondsOf = (timestamp: string): number =>
-    Math.floor(Date.parse(timestamp) / 1000);
-
-  it('serves a repeated reminder path request from one read of the transcript', async () => {
-    const transcriptPath = writeTranscript('session.jsonl', [
-      assistantWithMarker('2026-08-13T10:00:00.000Z'),
-    ]);
-    const transcriptPathBySessionName = new Map([['session', transcriptPath]]);
-    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
-
-    const firstEpochSeconds =
-      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
-        transcriptPathBySessionName,
-      );
-
-    writeTranscript('session.jsonl', [
-      assistantWithMarker('2026-08-13T11:00:00.000Z'),
-    ]);
-
-    const secondEpochSeconds =
-      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
-        transcriptPathBySessionName,
-      );
-
-    expect(firstEpochSeconds.get('session')).toBe(
-      epochSecondsOf('2026-08-13T10:00:00.000Z'),
-    );
-    expect(secondEpochSeconds.get('session')).toBe(
-      epochSecondsOf('2026-08-13T10:00:00.000Z'),
-    );
-  });
-
-  it('scans a transcript that only the reminder path asked for', async () => {
-    const transcriptPath = writeTranscript('reminder-only.jsonl', [
-      assistantWithMarker('2026-08-13T12:00:00.000Z'),
-    ]);
-    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
-
-    const epochSeconds =
-      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
-        new Map([['session', transcriptPath]]),
-      );
-
-    expect(epochSeconds.get('session')).toBe(
-      epochSecondsOf('2026-08-13T12:00:00.000Z'),
-    );
-  });
-});