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

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -1,396 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
-import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
-
-type TranscriptOwnerCall = {
-  epochMs: number;
-  candidateOnly: boolean;
-};
-
-type TranscriptOwnerCallScan = {
-  ownerCalls: TranscriptOwnerCall[];
-  lastOwnerReplyEpochMs: number | null;
-};
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
-const readString = (
-  value: Record<string, unknown>,
-  key: string,
-): string | null => {
-  const candidate = value[key];
-  return typeof candidate === 'string' ? candidate : null;
-};
-
-const parseEpochMilliseconds = (timestamp: string | null): number | null => {
-  if (timestamp === null) {
-    return null;
-  }
-  const parsed = Date.parse(timestamp);
-  return Number.isNaN(parsed) ? null : parsed;
-};
-
-const extractText = (content: unknown): string => {
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return '';
-  }
-  const texts: string[] = [];
-  for (const block of content) {
-    if (isRecord(block) && block.type === 'text') {
-      const text = readString(block, 'text');
-      if (text !== null) {
-        texts.push(text);
-      }
-    }
-  }
-  return texts.join('\n');
-};
-
-// A transcript user entry is only a genuine owner reply when it was actually
-// typed (or queued) by the human owner. Claude Code records the provenance of
-// each user entry on the top-level `origin` and `promptSource` fields. A
-// genuine human prompt is identified by EITHER `origin.kind === 'human'` OR a
-// `promptSource` of `typed`/`queued`; the second condition is required because
-// older-format transcripts record genuine human replies with a `promptSource`
-// of `queued`/`typed` but no `origin` field, and dropping those would leave a
-// real owner reply uncounted and the session waiting forever. Every
-// system-injected user entry, by contrast, uses a `promptSource` of `system`
-// (sub-agent `task-notification` notices, cross-session `peer` messages) or
-// `sdk` (spawn prompts), or has neither field (tool results, skill/meta
-// entries) — none of which match. Only a genuine human entry may clear an
-// outstanding call-to-user; otherwise a system-injected entry would be
-// miscounted as the owner answering and a genuinely waiting session would stop
-// being suppressed.
-const isGenuineHumanEntry = (parsed: Record<string, unknown>): boolean => {
-  const origin = parsed.origin;
-  if (isRecord(origin) && readString(origin, 'kind') === 'human') {
-    return true;
-  }
-  const promptSource = readString(parsed, 'promptSource');
-  return promptSource === 'typed' || promptSource === 'queued';
-};
-
-const hasOwnerTextReply = (content: unknown): boolean => {
-  if (typeof content === 'string') {
-    if (content.length === 0) {
-      return false;
-    }
-    // A monitor-injected self-check reminder lands in the target session's
-    // transcript as a user text entry. It carries the reminder sentinel, so it
-    // is the monitor talking to the session, not the owner replying. It MUST NOT
-    // advance the last-owner-reply time, otherwise an outstanding call-to-user
-    // is wrongly treated as answered and the session stops being suppressed.
-    return !content.includes(SILENT_SESSION_REMINDER_SENTINEL);
-  }
-  if (!Array.isArray(content)) {
-    return false;
-  }
-  const hasTextBlock = content.some(
-    (block) => isRecord(block) && block.type === 'text',
-  );
-  if (!hasTextBlock) {
-    return false;
-  }
-  return !extractText(content).includes(SILENT_SESSION_REMINDER_SENTINEL);
-};
-
-const OWNER_CALL_TAG_TERMINATOR = '>';
-const OWNER_CALL_CANDIDATE_TAG_INFIX = '-pending';
-const OWNER_CALL_CANDIDATE_TAG_SUFFIX = `${OWNER_CALL_CANDIDATE_TAG_INFIX}${OWNER_CALL_TAG_TERMINATOR}`;
-
-export const ownerCallMarkerFamilyResolve = (marker: string): string[] =>
-  marker.endsWith(OWNER_CALL_TAG_TERMINATOR)
-    ? [
-        marker,
-        `${marker.slice(0, -OWNER_CALL_TAG_TERMINATOR.length)}${OWNER_CALL_CANDIDATE_TAG_SUFFIX}`,
-      ]
-    : [marker];
-
-// A reply the owner types while the agent is still working is NOT written as a `user` entry: the
-// running turn consumes it from the queue, and the transcript keeps only
-// {"type":"queue-operation","operation":"enqueue","content":"<the text>"} plus its `remove` twin.
-// Reading `user` entries alone therefore misses every mid-turn reply, leaves the call outstanding
-// for the rest of the session, and suppresses the stall reminder of a session the owner has
-// already answered. The exclusions match the ones the status line applies to the same entries, so
-// a system-injected enqueue never counts as an owner reply.
-const INJECTED_ENQUEUE_CONTENT_MARKERS = [
-  SILENT_SESSION_REMINDER_SENTINEL,
-  '<system-reminder>',
-  'UserPromptSubmit hook',
-  '<task-notification>',
-  'SYSTEM NOTIFICATION',
-  '<local-command-stdout>',
-  '<local-command-caveat>',
-  '<command-name>',
-  'This session is being continued from a previous conversation',
-];
-
-const isOwnerEnqueuedReply = (parsed: Record<string, unknown>): boolean => {
-  if (readString(parsed, 'operation') !== 'enqueue') {
-    return false;
-  }
-  const content = readString(parsed, 'content');
-  if (content === null || content.length === 0) {
-    return false;
-  }
-  return !INJECTED_ENQUEUE_CONTENT_MARKERS.some((injectedMarker) =>
-    content.includes(injectedMarker),
-  );
-};
-
-const TRANSCRIPT_FILE_EXTENSION = '.jsonl';
-const OWNER_REPLY_MARKER_FILE_EXTENSION = '.reply_ts';
-const SUPPRESSED_OWNER_CALL_MARKER_FILE_EXTENSION = '.suppress_ts';
-const APPROVED_OWNER_CALL_MARKER_FILE_EXTENSION = '.call_ts';
-const EMITTED_OWNER_CALL_MARKER_FILE_EXTENSION = '.call_emitted';
-const UNSAFE_SESSION_ID_CHARACTER_PATTERN = /[^A-Za-z0-9._-]/g;
-
-const isCandidateOwnerCallMarker = (marker: string): boolean =>
-  marker.endsWith(OWNER_CALL_CANDIDATE_TAG_SUFFIX);
-
-export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
-  private readonly ownerCallMarkerFamily: string[];
-
-  private readonly transcriptScanByPath = new Map<
-    string,
-    TranscriptOwnerCallScan | null
-  >();
-
-  constructor(
-    ownerCallMarker: string | null,
-    private readonly ownerReplyMarkerDirectory: string | null = null,
-  ) {
-    this.ownerCallMarkerFamily =
-      ownerCallMarker === null || ownerCallMarker.length === 0
-        ? []
-        : ownerCallMarkerFamilyResolve(ownerCallMarker);
-  }
-
-  listUnansweredOwnerCallEpochSecondsBySessionName = async (
-    transcriptPathBySessionName: Map<string, string>,
-  ): Promise<Map<string, number>> => {
-    const unansweredOwnerCallEpochSecondsBySessionName = new Map<
-      string,
-      number
-    >();
-    if (this.ownerCallMarkerFamily.length === 0) {
-      return unansweredOwnerCallEpochSecondsBySessionName;
-    }
-    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const unansweredOwnerCallEpochMs =
-        this.findUnansweredOwnerCallEpochMs(transcriptPath);
-      if (unansweredOwnerCallEpochMs !== null) {
-        unansweredOwnerCallEpochSecondsBySessionName.set(
-          sessionName,
-          Math.floor(unansweredOwnerCallEpochMs / 1000),
-        );
-      }
-    }
-    return unansweredOwnerCallEpochSecondsBySessionName;
-  };
-
-  private scanTranscript = (
-    transcriptPath: string,
-  ): TranscriptOwnerCallScan | null => {
-    const alreadyScanned = this.transcriptScanByPath.get(transcriptPath);
-    if (alreadyScanned !== undefined) {
-      return alreadyScanned;
-    }
-    const scan = this.readTranscriptScan(transcriptPath);
-    this.transcriptScanByPath.set(transcriptPath, scan);
-    return scan;
-  };
-
-  private readTranscriptScan = (
-    transcriptPath: string,
-  ): TranscriptOwnerCallScan | null => {
-    const markerFamily = this.ownerCallMarkerFamily;
-    let content: string;
-    try {
-      content = fs.readFileSync(transcriptPath, 'utf8');
-    } catch {
-      return null;
-    }
-    const ownerCalls: TranscriptOwnerCall[] = [];
-    let lastOwnerReplyEpochMs: number | null = null;
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed.length === 0) {
-        continue;
-      }
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      if (!isRecord(parsed)) {
-        continue;
-      }
-      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
-      if (epochMs === null) {
-        continue;
-      }
-      const type = readString(parsed, 'type');
-      const message = parsed.message;
-      const messageContent = isRecord(message) ? message.content : null;
-      if (type === 'assistant') {
-        const assistantText = extractText(messageContent);
-        const matchedMarkers = markerFamily.filter((marker) =>
-          assistantText.includes(marker),
-        );
-        if (matchedMarkers.length > 0) {
-          ownerCalls.push({
-            epochMs,
-            candidateOnly: matchedMarkers.every(isCandidateOwnerCallMarker),
-          });
-        }
-      }
-      if (
-        type === 'user' &&
-        isGenuineHumanEntry(parsed) &&
-        hasOwnerTextReply(messageContent)
-      ) {
-        lastOwnerReplyEpochMs = epochMs;
-      }
-      if (type === 'queue-operation' && isOwnerEnqueuedReply(parsed)) {
-        lastOwnerReplyEpochMs =
-          lastOwnerReplyEpochMs === null || epochMs > lastOwnerReplyEpochMs
-            ? epochMs
-            : lastOwnerReplyEpochMs;
-      }
-    }
-    return { ownerCalls, lastOwnerReplyEpochMs };
-  };
-
-  private resolveReplyEpochMs = (
-    transcriptPath: string,
-    lastOwnerReplyEpochMs: number | null,
-  ): number | null => {
-    const markerReplyEpochMs = this.readOwnerReplyMarkerEpochMs(transcriptPath);
-    return markerReplyEpochMs !== null &&
-      (lastOwnerReplyEpochMs === null ||
-        markerReplyEpochMs > lastOwnerReplyEpochMs)
-      ? markerReplyEpochMs
-      : lastOwnerReplyEpochMs;
-  };
-
-  private findUnansweredOwnerCallEpochMs = (
-    transcriptPath: string,
-  ): number | null => {
-    const transcript = this.scanTranscript(transcriptPath);
-    if (transcript === null) {
-      return null;
-    }
-    const lastOwnerCall =
-      transcript.ownerCalls[transcript.ownerCalls.length - 1] ?? null;
-    if (lastOwnerCall === null) {
-      return null;
-    }
-    const lastOwnerCallEpochMs = lastOwnerCall.epochMs;
-    if (
-      this.isCallSuppressedUndelivered(transcriptPath, lastOwnerCallEpochMs)
-    ) {
-      return null;
-    }
-    if (
-      lastOwnerCall.candidateOnly &&
-      !this.isCandidateCallDelivered(transcriptPath, lastOwnerCallEpochMs)
-    ) {
-      return null;
-    }
-    const resolvedReplyEpochMs = this.resolveReplyEpochMs(
-      transcriptPath,
-      transcript.lastOwnerReplyEpochMs,
-    );
-    return resolvedReplyEpochMs === null ||
-      lastOwnerCallEpochMs > resolvedReplyEpochMs
-      ? lastOwnerCallEpochMs
-      : null;
-  };
-
-  // The owner sees only the status line, so the reply time it renders is the value the owner
-  // believes the fleet is acting on. The status line writes that value to a per-session marker
-  // file, and reading it here keeps this decision and the owner's own view of it from diverging.
-  // The transcript-derived value still stands on its own: an absent, unreadable, or older marker
-  // changes nothing, so a fresh host with no markers yet behaves exactly as before.
-  private readOwnerReplyMarkerEpochMs = (
-    transcriptPath: string,
-  ): number | null =>
-    this.readMarkerEpochMs(transcriptPath, OWNER_REPLY_MARKER_FILE_EXTENSION);
-
-  private isCallSuppressedUndelivered = (
-    transcriptPath: string,
-    ownerCallEpochMs: number,
-  ): boolean => {
-    const suppressedEpochMs = this.readMarkerEpochMs(
-      transcriptPath,
-      SUPPRESSED_OWNER_CALL_MARKER_FILE_EXTENSION,
-    );
-    if (suppressedEpochMs === null || suppressedEpochMs !== ownerCallEpochMs) {
-      return false;
-    }
-    const approvedEpochMs = this.readMarkerEpochMs(
-      transcriptPath,
-      APPROVED_OWNER_CALL_MARKER_FILE_EXTENSION,
-    );
-    return approvedEpochMs !== suppressedEpochMs;
-  };
-
-  private isCandidateCallDelivered = (
-    transcriptPath: string,
-    ownerCallEpochMs: number,
-  ): boolean => {
-    if (this.ownerReplyMarkerDirectory === null) {
-      return true;
-    }
-    const emittedEpochMs = this.readMarkerEpochMs(
-      transcriptPath,
-      EMITTED_OWNER_CALL_MARKER_FILE_EXTENSION,
-    );
-    if (emittedEpochMs === ownerCallEpochMs) {
-      return true;
-    }
-    return (
-      this.readMarkerEpochMs(
-        transcriptPath,
-        APPROVED_OWNER_CALL_MARKER_FILE_EXTENSION,
-      ) === ownerCallEpochMs
-    );
-  };
-
-  private readMarkerEpochMs = (
-    transcriptPath: string,
-    markerFileExtension: string,
-  ): number | null => {
-    if (this.ownerReplyMarkerDirectory === null) {
-      return null;
-    }
-    const fileName = path.basename(transcriptPath);
-    const sessionId = fileName.endsWith(TRANSCRIPT_FILE_EXTENSION)
-      ? fileName.slice(0, -TRANSCRIPT_FILE_EXTENSION.length)
-      : fileName;
-    const safeSessionId = sessionId.replace(
-      UNSAFE_SESSION_ID_CHARACTER_PATTERN,
-      '_',
-    );
-    let markerContent: string;
-    try {
-      markerContent = fs.readFileSync(
-        path.join(
-          this.ownerReplyMarkerDirectory,
-          `${safeSessionId}${markerFileExtension}`,
-        ),
-        'utf8',
-      );
-    } catch {
-      return null;
-    }
-    return parseEpochMilliseconds(markerContent.split('\n')[0].trim());
-  };
-}

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

@@ -1,208 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TranscriptRefusalTailStatusProvider } from './TranscriptRefusalTailStatusProvider';
-
-describe('TranscriptRefusalTailStatusProvider', () => {
-  let rootDirectory: string;
-  let provider: TranscriptRefusalTailStatusProvider;
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'refusal-tail-status-'),
-    );
-    provider = new TranscriptRefusalTailStatusProvider();
-  });
-
-  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 refusalSystemEntry = (timestamp: string): object => ({
-    type: 'system',
-    subtype: 'model_refusal_no_fallback',
-    timestamp,
-  });
-
-  const refusalAssistantEntry = (timestamp: string): object => ({
-    type: 'assistant',
-    timestamp,
-    message: {
-      role: 'assistant',
-      stop_reason: 'refusal',
-      content: [],
-    },
-  });
-
-  const normalAssistantEntry = (timestamp: string): object => ({
-    type: 'assistant',
-    timestamp,
-    message: {
-      role: 'assistant',
-      stop_reason: 'end_turn',
-      content: [{ type: 'text', text: 'progress update' }],
-    },
-  });
-
-  const userEntry = (timestamp: string): object => ({
-    type: 'user',
-    timestamp,
-    promptSource: 'system',
-    message: { role: 'user', content: 'injected reminder' },
-  });
-
-  it('reports a session whose transcript ends with a refusal assistant entry', async () => {
-    const transcriptPath = writeTranscript('refusal-tail.jsonl', [
-      normalAssistantEntry('2026-07-12T00:00:00Z'),
-      userEntry('2026-07-12T00:10:00Z'),
-      refusalSystemEntry('2026-07-12T00:10:05Z'),
-      refusalAssistantEntry('2026-07-12T00:10:06Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-refusal', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set(['session-refusal']));
-  });
-
-  it('reports a session whose transcript ends with repeated refusal entries', async () => {
-    const transcriptPath = writeTranscript('refusal-loop.jsonl', [
-      normalAssistantEntry('2026-07-12T00:00:00Z'),
-      userEntry('2026-07-12T00:10:00Z'),
-      refusalSystemEntry('2026-07-12T00:10:05Z'),
-      refusalAssistantEntry('2026-07-12T00:10:06Z'),
-      userEntry('2026-07-12T00:20:00Z'),
-      refusalSystemEntry('2026-07-12T00:20:05Z'),
-      refusalAssistantEntry('2026-07-12T00:20:06Z'),
-      userEntry('2026-07-12T00:30:00Z'),
-      refusalSystemEntry('2026-07-12T00:30:05Z'),
-      refusalAssistantEntry('2026-07-12T00:30:06Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-refusal-loop', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set(['session-refusal-loop']));
-  });
-
-  it('detects a refusal recorded on the top-level stop_reason field', async () => {
-    const transcriptPath = writeTranscript('refusal-top-level.jsonl', [
-      normalAssistantEntry('2026-07-12T00:00:00Z'),
-      {
-        type: 'assistant',
-        timestamp: '2026-07-12T00:10:06Z',
-        stop_reason: 'refusal',
-        message: { role: 'assistant', content: [] },
-      },
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-top-level', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set(['session-top-level']));
-  });
-
-  it('does not report a session when a normal assistant turn follows the refusal', async () => {
-    const transcriptPath = writeTranscript('refusal-recovered.jsonl', [
-      refusalSystemEntry('2026-07-12T00:10:05Z'),
-      refusalAssistantEntry('2026-07-12T00:10:06Z'),
-      userEntry('2026-07-12T00:20:00Z'),
-      normalAssistantEntry('2026-07-12T00:20:30Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-recovered', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('does not report a session when trailing non-assistant entries follow the last normal assistant turn', async () => {
-    const transcriptPath = writeTranscript('trailing-user.jsonl', [
-      refusalAssistantEntry('2026-07-12T00:10:06Z'),
-      normalAssistantEntry('2026-07-12T00:20:30Z'),
-      userEntry('2026-07-12T00:30:00Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-trailing-user', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('does not report a session whose transcript has no refusal entries', async () => {
-    const transcriptPath = writeTranscript('no-refusal.jsonl', [
-      normalAssistantEntry('2026-07-12T00:00:00Z'),
-      userEntry('2026-07-12T00:10:00Z'),
-      normalAssistantEntry('2026-07-12T00:20:30Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-normal', transcriptPath]]),
-    );
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('does not report a session whose transcript file is missing', async () => {
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([
-        ['session-missing', path.join(rootDirectory, 'does-not-exist.jsonl')],
-      ]),
-    );
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('skips malformed lines and still detects the refusal tail', async () => {
-    const filePath = path.join(rootDirectory, 'malformed.jsonl');
-    fs.writeFileSync(
-      filePath,
-      [
-        JSON.stringify(normalAssistantEntry('2026-07-12T00:00:00Z')),
-        'not-json',
-        '',
-        JSON.stringify(refusalAssistantEntry('2026-07-12T00:10:06Z')),
-      ].join('\n'),
-      'utf8',
-    );
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([['session-malformed', filePath]]),
-    );
-
-    expect(result).toEqual(new Set(['session-malformed']));
-  });
-
-  it('evaluates each session independently', async () => {
-    const refusalPath = writeTranscript('multi-refusal.jsonl', [
-      refusalAssistantEntry('2026-07-12T00:10:06Z'),
-    ]);
-    const normalPath = writeTranscript('multi-normal.jsonl', [
-      normalAssistantEntry('2026-07-12T00:10:06Z'),
-    ]);
-
-    const result = await provider.listRefusalTailedSessionNames(
-      new Map([
-        ['session-a', refusalPath],
-        ['session-b', normalPath],
-      ]),
-    );
-
-    expect(result).toEqual(new Set(['session-a']));
-  });
-});

package/src/adapter/repositories/TranscriptRefusalTailStatusProvider.ts

@@ -1,80 +0,0 @@
-import * as fs from 'fs';
-import { RefusalTailStatusProvider } from '../../domain/usecases/adapter-interfaces/RefusalTailStatusProvider';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
-const readString = (
-  value: Record<string, unknown>,
-  key: string,
-): string | null => {
-  const candidate = value[key];
-  return typeof candidate === 'string' ? candidate : null;
-};
-
-// A model refusal is durably recorded in the session transcript JSONL as an
-// assistant entry whose stop reason is `refusal` (a system entry with
-// `subtype: 'model_refusal_no_fallback'` precedes it). The stop reason lives
-// on the embedded API message (`message.stop_reason`); the top-level field is
-// also checked for robustness against transcript format variations.
-const isRefusalAssistantEntry = (parsed: Record<string, unknown>): boolean => {
-  if (readString(parsed, 'type') !== 'assistant') {
-    return false;
-  }
-  if (readString(parsed, 'stop_reason') === 'refusal') {
-    return true;
-  }
-  const message = parsed.message;
-  return isRecord(message) && readString(message, 'stop_reason') === 'refusal';
-};
-
-export class TranscriptRefusalTailStatusProvider implements RefusalTailStatusProvider {
-  // A session is refusal-tailed when the most recent assistant entry in its
-  // transcript is a model refusal. Sending a reminder to such a session is
-  // guaranteed to burn a full-context API call and produce another refusal,
-  // so the monitor excludes it from reminder candidates. The gate is purely
-  // state-based: as soon as any non-refusal assistant entry appears after the
-  // refusal (manual nudge, restart, compaction), the session is no longer
-  // refusal-tailed and reminders resume.
-  listRefusalTailedSessionNames = async (
-    transcriptPathBySessionName: Map<string, string>,
-  ): Promise<Set<string>> => {
-    const refusalTailedSessionNames = new Set<string>();
-    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      if (this.isTranscriptRefusalTailed(transcriptPath)) {
-        refusalTailedSessionNames.add(sessionName);
-      }
-    }
-    return refusalTailedSessionNames;
-  };
-
-  private isTranscriptRefusalTailed = (transcriptPath: string): boolean => {
-    let content: string;
-    try {
-      content = fs.readFileSync(transcriptPath, 'utf8');
-    } catch {
-      return false;
-    }
-    let lastAssistantEntryIsRefusal = false;
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed.length === 0) {
-        continue;
-      }
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      if (!isRecord(parsed)) {
-        continue;
-      }
-      if (readString(parsed, 'type') !== 'assistant') {
-        continue;
-      }
-      lastAssistantEntryIsRefusal = isRefusalAssistantEntry(parsed);
-    }
-    return lastAssistantEntryIsRefusal;
-  };
-}