github-issue-tower-defence-management 1.146.5 → 1.146.6

package/src/adapter/entry-points/cli/index.ts

@@ -919,7 +919,7 @@ addServeWebOptions(program.command('serveConsole'))
 program
   .command('selectOauthToken')
   .description(
-    'Print exactly one Claude Code OAuth token chosen by a rate-limit-aware filter. When tokens carry differing per-token selectionWeight values, the choice among rate-limit-eligible tokens is weighted-random by that weight (default 1), so a lower-weight token is chosen proportionally less often; uniform weights preserve the deterministic soonest-7d-reset choice. The token string is written to stdout (pipeable); the per-candidate decision trace is written to stderr. Exits non-zero when no token passes the filter.',
+    'Print exactly one Claude Code OAuth token chosen by a rate-limit-aware filter. Among rate-limit-eligible tokens the choice is weighted-random, with each token weighted by its per-token selectionWeight (default 1) multiplied by how urgent its 7d window is (the free share of that window times 168 divided by the hours left before it resets, with those hours floored at 1), so a token holding unused allowance that resets soon is chosen more often. When every eligible weight is identical, the choice stays deterministic and no random draw is made. The token string is written to stdout (pipeable); the per-candidate decision trace is written to stderr. Exits non-zero when no token passes the filter.',
   )
   .option(
     '--tokenListJsonPath <path>',
@@ -951,7 +951,7 @@ program
 program
   .command('selectLiveSessionOauthToken')
   .description(
-    'Print exactly one Claude Code OAuth token chosen for a new live interactive session. Among rate-limit-eligible tokens it prefers the one with the fewest current live sessions (by distinct CLAUDE_CODE_SESSION_ID found in running Claude Code processes), tiebreaking on the soonest 7d reset. When tokens carry differing per-token selectionWeight values, the choice among eligible tokens is weighted-random by that weight (default 1), so a lower-weight token is chosen proportionally less often; uniform weights preserve the fewest-live-sessions-then-soonest-7d-reset choice. The token string is written to stdout (pipeable); the per-candidate decision trace is written to stderr. Exits non-zero when no token passes the filter.',
+    'Print exactly one Claude Code OAuth token chosen for a new live interactive session. Among rate-limit-eligible tokens the choice is weighted-random, with each token weighted by its per-token selectionWeight (default 1), multiplied by how urgent its 7d window is (the free share of that window times 168 divided by the hours left before it resets, with those hours floored at 1), and divided by one plus its current live session count (by distinct CLAUDE_CODE_SESSION_ID found in running Claude Code processes). A token whose 7d window still holds unused allowance and resets soon is therefore chosen more often, while occupancy keeps sessions spread across tokens. When every eligible weight is identical, the choice stays deterministic and no random draw is made. The token string is written to stdout (pipeable); the per-candidate decision trace is written to stderr. Exits non-zero when no token passes the filter.',
   )
   .option(
     '--tokenListJsonPath <path>',

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.test.ts

@@ -109,10 +109,12 @@ describe('LiveSessionOauthTokenSelectHandler', () => {
 
   const buildHandler = (
     sessions: ClaudeLiveSession[],
+    random: () => number = () => 0.5,
   ): LiveSessionOauthTokenSelectHandler =>
     new LiveSessionOauthTokenSelectHandler(
       new LiveSessionOauthTokenSelectUseCase(),
       new FakeClaudeLiveSessionRepository(sessions),
+      random,
     );
 
   const writeFableRejectionCache = (token: string, resetsAt: number): void => {
@@ -163,7 +165,7 @@ describe('LiveSessionOauthTokenSelectHandler', () => {
     );
   });
 
-  it('selects the eligible token with the fewest live sessions', () => {
+  it('selects the eligible token with fewer live sessions for a draw inside its weight slice', () => {
     writeTokenList([
       { name: 'busy', token: 'fake-busy' },
       { name: 'idle', token: 'fake-idle' },
@@ -181,9 +183,10 @@ describe('LiveSessionOauthTokenSelectHandler', () => {
       sevenDayReset: NOW + 6 * DAY,
     });
 
-    const handler = buildHandler([
-      { token: 'fake-busy', sessionKey: 'session-a' },
-    ]);
+    const handler = buildHandler(
+      [{ token: 'fake-busy', sessionKey: 'session-a' }],
+      () => 0.9,
+    );
     const output = handler.handle({
       tokenListJsonPath: tokenListPath,
       cacheDirectory,

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.ts

@@ -8,6 +8,7 @@ import {
   FIVE_HOUR_MIN_FREE_RATIO,
   OauthTokenCandidate,
   SEVEN_DAY_MIN_FREE_RATIO,
+  SelectionRandom,
 } from '../../../domain/usecases/OauthTokenSelectUseCase';
 import { ProcClaudeLiveSessionRepository } from '../../repositories/ProcClaudeLiveSessionRepository';
 import { FABLE_LIMIT_TYPE, readRateLimit } from '../../proxy/RateLimitCache';
@@ -33,6 +34,7 @@ export class LiveSessionOauthTokenSelectHandler {
   constructor(
     private readonly useCase: LiveSessionOauthTokenSelectUseCase = new LiveSessionOauthTokenSelectUseCase(),
     private readonly liveSessionRepository: ClaudeLiveSessionRepository = new ProcClaudeLiveSessionRepository(),
+    private readonly random: SelectionRandom = Math.random,
   ) {}
 
   handle = (
@@ -96,6 +98,7 @@ export class LiveSessionOauthTokenSelectHandler {
       candidates,
       liveSessions,
       input.nowEpochSeconds,
+      this.random,
     );
 
     return {
@@ -125,7 +128,7 @@ export class LiveSessionOauthTokenSelectHandler {
       );
     } else {
       lines.push(
-        `Selected ${result.selected.name} (fewest live sessions, then soonest 7d reset among eligible tokens).`,
+        `Selected ${result.selected.name} (weighted by how soon the 7d window resets, how much of it is free, and how few live sessions the token carries).`,
       );
     }
 

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.test.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { OauthTokenSelectUseCase } from '../../../domain/usecases/OauthTokenSelectUseCase';
 import { FABLE_LIMIT_TYPE, hashToken } from '../../proxy/RateLimitCache';
 import {
   OauthTokenSelectHandler,
@@ -122,7 +123,7 @@ describe('OauthTokenSelectHandler', () => {
     );
   };
 
-  it('selects the eligible token with the soonest 7d reset', () => {
+  it('selects the token whose 7d window resets soonest for a draw inside its weight slice', () => {
     writeTokenList([
       { name: 'far', token: 'fake-far' },
       { name: 'soon', token: 'fake-soon' },
@@ -140,7 +141,10 @@ describe('OauthTokenSelectHandler', () => {
       sevenDayReset: NOW + 2 * DAY,
     });
 
-    const handler = new OauthTokenSelectHandler();
+    const handler = new OauthTokenSelectHandler(
+      new OauthTokenSelectUseCase(),
+      () => 0.5,
+    );
     const output = handler.handle({
       tokenListJsonPath: tokenListPath,
       cacheDirectory,

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.ts

@@ -3,6 +3,7 @@ import {
   OauthTokenCandidate,
   OauthTokenSelectResult,
   OauthTokenSelectUseCase,
+  SelectionRandom,
 } from '../../../domain/usecases/OauthTokenSelectUseCase';
 import {
   FABLE_LIMIT_TYPE,
@@ -55,6 +56,7 @@ export const resolveCacheDirectory = (
 export class OauthTokenSelectHandler {
   constructor(
     private readonly useCase: OauthTokenSelectUseCase = new OauthTokenSelectUseCase(),
+    private readonly random: SelectionRandom = Math.random,
   ) {}
 
   handle = (
@@ -112,7 +114,11 @@ export class OauthTokenSelectHandler {
       },
     );
 
-    const result = this.useCase.run(candidates, input.nowEpochSeconds);
+    const result = this.useCase.run(
+      candidates,
+      input.nowEpochSeconds,
+      this.random,
+    );
 
     return {
       selectedToken: result.selected?.token ?? null,
@@ -139,7 +145,7 @@ export class OauthTokenSelectHandler {
       lines.push('No eligible token passed the rate-limit filter.');
     } else {
       lines.push(
-        `Selected ${result.selected.name} (soonest 7d reset among eligible tokens).`,
+        `Selected ${result.selected.name} (weighted by how soon the 7d window resets and how much of it is free among eligible tokens).`,
       );
     }
 

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.test.ts

@@ -147,6 +147,7 @@ describe('notifySilentTmuxSessions', () => {
     messageTemplates: EMPTY_TEMPLATES,
     now: NOW,
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
+    submitPushOutWaitMilliseconds: 0,
   });
 
   it('sends a main stalled notification to a silent github-named live session that was already a candidate in the previous cycle', async () => {

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts

@@ -18,7 +18,11 @@ import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositori
 import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
 import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
 import { FileSystemSessionOutputActivityRepository } from '../../repositories/FileSystemSessionOutputActivityRepository';
-import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
+import {
+  DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT,
+  DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS,
+  TmuxSilentSessionNotificationRepository,
+} from '../../repositories/TmuxSilentSessionNotificationRepository';
 import { NoUnansweredOwnerCallStatusProvider } from '../../repositories/NoUnansweredOwnerCallStatusProvider';
 import { TranscriptOwnerCallStatusProvider } from '../../repositories/TranscriptOwnerCallStatusProvider';
 import { TranscriptRefusalTailStatusProvider } from '../../repositories/TranscriptRefusalTailStatusProvider';
@@ -57,6 +61,7 @@ export type NotifySilentTmuxSessionsParams = {
   hubTaskStatusCacheStateFilePath: string | null;
   hubTaskStatusCacheTtlSeconds: number;
   messageTemplates: SilentSessionMessageTemplates;
+  submitPushOutWaitMilliseconds?: number;
   now: Date;
 };
 
@@ -121,6 +126,7 @@ export const notifySilentTmuxSessions = async (
     hubTaskStatusCacheStateFilePath,
     hubTaskStatusCacheTtlSeconds,
     messageTemplates,
+    submitPushOutWaitMilliseconds,
     now,
   } = params;
   if (!enabled) {
@@ -149,7 +155,13 @@ export const notifySilentTmuxSessions = async (
       now,
     ),
     createOwnerCallStatusProvider(ownerCallMarker),
-    new TmuxSilentSessionNotificationRepository(localCommandRunner),
+    new TmuxSilentSessionNotificationRepository(
+      localCommandRunner,
+      new RealSleeper(),
+      DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT,
+      submitPushOutWaitMilliseconds ??
+        DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS,
+    ),
     candidateDebounceStateFilePath !== null
       ? new FileSystemSilentSessionCandidateStateRepository(
           candidateDebounceStateFilePath,

package/src/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.ts

@@ -46,7 +46,10 @@ export const resetDegeneratedTmuxSessions = async (
     ),
     new FileSystemInteractiveLiveSessionTranscriptResolver(),
     new FileSystemSessionAssistantTurnsRepository(),
-    new TmuxSilentSessionNotificationRepository(localCommandRunner),
+    new TmuxSilentSessionNotificationRepository(
+      localCommandRunner,
+      new RealSleeper(),
+    ),
     new NodeTmuxSessionRepository(localCommandRunner),
     cooldownStateFilePath !== null
       ? new FileSystemSessionDegenerationCooldownStateRepository(

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

@@ -1,4 +1,5 @@
 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>;
@@ -11,14 +12,55 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   }),
 });
 
+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 });
+    }),
+  };
+};
+
+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);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        createMockSleeper(),
+      );
 
       await repository.sendSelfCheckNotification(
-        'https_//github_com/owner/repo/issues/9',
+        sessionName,
         'self check message',
       );
 
@@ -27,26 +69,26 @@ describe('TmuxSilentSessionNotificationRepository', () => {
         [
           'send-keys',
           '-t',
-          'https_//github_com/owner/repo/issues/9',
+          sessionName,
           '-l',
           '\x1b[200~self check message\x1b[201~',
         ],
       ]);
       expect(runner.runCommand.mock.calls[1]).toEqual([
         'tmux',
-        ['send-keys', '-t', 'https_//github_com/owner/repo/issues/9', 'Enter'],
+        ['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);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        createMockSleeper(),
+      );
       const multiLineMessage = 'first line\nsecond line\n\nthird line';
 
-      await repository.sendSelfCheckNotification(
-        'https_//github_com/owner/repo/issues/9',
-        multiLineMessage,
-      );
+      await repository.sendSelfCheckNotification(sessionName, multiLineMessage);
 
       const literalArgument = runner.runCommand.mock.calls[0][1][4];
       expect(literalArgument).not.toContain('\n');
@@ -58,10 +100,13 @@ describe('TmuxSilentSessionNotificationRepository', () => {
 
     it('keeps the bracketed-paste framing around the flattened message', async () => {
       const runner = createMockRunner();
-      const repository = new TmuxSilentSessionNotificationRepository(runner);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        createMockSleeper(),
+      );
 
       await repository.sendSelfCheckNotification(
-        'https_//github_com/owner/repo/issues/9',
+        sessionName,
         'first line\nsecond line',
       );
 
@@ -71,16 +116,19 @@ describe('TmuxSilentSessionNotificationRepository', () => {
       expect(literalBytes.endsWith('1b5b3230317e')).toBe(true);
       expect(runner.runCommand.mock.calls[1]).toEqual([
         'tmux',
-        ['send-keys', '-t', 'https_//github_com/owner/repo/issues/9', 'Enter'],
+        ['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);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        createMockSleeper(),
+      );
 
       await repository.sendSelfCheckNotification(
-        'https_//github_com/owner/repo/issues/9',
+        sessionName,
         'section one\n\n\nsection two',
       );
 
@@ -97,7 +145,10 @@ describe('TmuxSilentSessionNotificationRepository', () => {
         stderr: "can't find session",
         exitCode: 1,
       });
-      const repository = new TmuxSilentSessionNotificationRepository(runner);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        createMockSleeper(),
+      );
 
       await expect(
         repository.sendSelfCheckNotification('missing_session', 'message'),
@@ -105,5 +156,96 @@ describe('TmuxSilentSessionNotificationRepository', () => {
         '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,11 +1,66 @@
 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) {}
+  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,
@@ -27,6 +82,11 @@ export class TmuxSilentSessionNotificationRepository implements SilentSessionNot
         }`,
       );
     }
+    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',
@@ -41,4 +101,58 @@ export class TmuxSilentSessionNotificationRepository implements SilentSessionNot
       );
     }
   };
+
+  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,
+    );
+  };
 }