github-issue-tower-defence-management 1.140.2 → 1.141.0

package/src/adapter/repositories/FileSystemSessionAssistantTurnsRepository.ts

@@ -0,0 +1,113 @@
+import * as fs from 'fs';
+import { SessionAssistantTurnsRepository } from '../../domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository';
+
+export const DEFAULT_TRANSCRIPT_TAIL_BYTES = 3_000_000;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const assistantText = (message: Record<string, unknown>): string => {
+  const content = message.content;
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const block of content) {
+      if (
+        isRecord(block) &&
+        block.type === 'text' &&
+        typeof block.text === 'string'
+      ) {
+        parts.push(block.text);
+      }
+    }
+    return parts.join(' ');
+  }
+  return '';
+};
+
+export class FileSystemSessionAssistantTurnsRepository implements SessionAssistantTurnsRepository {
+  constructor(
+    private readonly tailBytes: number = DEFAULT_TRANSCRIPT_TAIL_BYTES,
+  ) {}
+
+  listRecentAssistantTurnsBySessionName = async (
+    transcriptPathBySessionName: Map<string, string>,
+    maxTurnsPerSession: number,
+  ): Promise<Map<string, string[]>> => {
+    const turnsBySessionName = new Map<string, string[]>();
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      const turns = this.readRecentAssistantTurns(
+        transcriptPath,
+        maxTurnsPerSession,
+      );
+      if (turns.length > 0) {
+        turnsBySessionName.set(sessionName, turns);
+      }
+    }
+    return turnsBySessionName;
+  };
+
+  private readRecentAssistantTurns = (
+    transcriptPath: string,
+    maxTurns: number,
+  ): string[] => {
+    const lines = this.readTailLines(transcriptPath);
+    const turns: string[] = [];
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const trimmed = lines[index].trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed) || parsed.type !== 'assistant') {
+        continue;
+      }
+      const message = parsed.message;
+      if (!isRecord(message)) {
+        continue;
+      }
+      const text = assistantText(message);
+      if (text.trim().length === 0) {
+        continue;
+      }
+      turns.push(text);
+      if (turns.length >= maxTurns) {
+        break;
+      }
+    }
+    return turns;
+  };
+
+  private readTailLines = (transcriptPath: string): string[] => {
+    let handle: number;
+    try {
+      handle = fs.openSync(transcriptPath, 'r');
+    } catch {
+      return [];
+    }
+    try {
+      const size = fs.fstatSync(handle).size;
+      const start = size > this.tailBytes ? size - this.tailBytes : 0;
+      const length = size - start;
+      const buffer = new Uint8Array(length);
+      fs.readSync(handle, buffer, 0, length, start);
+      let text = Buffer.from(buffer).toString('utf8');
+      if (start > 0) {
+        const newlineIndex = text.indexOf('\n');
+        text = newlineIndex === -1 ? '' : text.slice(newlineIndex + 1);
+      }
+      return text.split('\n');
+    } catch {
+      return [];
+    } finally {
+      fs.closeSync(handle);
+    }
+  };
+}

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

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionDegenerationCooldownStateRepository } from './FileSystemSessionDegenerationCooldownStateRepository';
+
+describe('FileSystemSessionDegenerationCooldownStateRepository', () => {
+  let temporaryDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'degeneration-cooldown-'),
+    );
+    stateFilePath = path.join(temporaryDirectory, 'cooldown.json');
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  it('returns an empty map when no state file exists', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    expect(await repository.loadLastResetEpochSecondsBySessionName()).toEqual(
+      new Map(),
+    );
+  });
+
+  it('persists and reloads a per-session reset time', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-07-26T00:00:00Z');
+    await repository.recordReset({ sessionName: 'session-a', now });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(Math.floor(now.getTime() / 1000));
+  });
+
+  it('keeps distinct sessions separate and overwrites the same session', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-b',
+      now: new Date('2026-07-26T00:01:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:02:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(
+      Math.floor(new Date('2026-07-26T00:02:00Z').getTime() / 1000),
+    );
+    expect(reloaded.get('session-b')).toBe(
+      Math.floor(new Date('2026-07-26T00:01:00Z').getTime() / 1000),
+    );
+  });
+
+  it('drops entries older than the retention window on the next write', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+      60,
+    );
+    await repository.recordReset({
+      sessionName: 'stale-session',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'fresh-session',
+      now: new Date('2026-07-26T00:05:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.has('stale-session')).toBe(false);
+    expect(reloaded.has('fresh-session')).toBe(true);
+  });
+});

package/src/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.ts

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SessionDegenerationCooldownStateRepository } from '../../domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository';
+
+type StoredResetEntry = {
+  sessionName: string;
+  resetEpochSeconds: number;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const DEFAULT_RESET_RETENTION_WINDOW_SECONDS = 60 * 60;
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'output-degeneration-cooldown.json');
+};
+
+export class FileSystemSessionDegenerationCooldownStateRepository implements SessionDegenerationCooldownStateRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_RESET_RETENTION_WINDOW_SECONDS,
+  ) {}
+
+  loadLastResetEpochSecondsBySessionName = async (): Promise<
+    Map<string, number>
+  > => {
+    const lastResetBySessionName = new Map<string, number>();
+    for (const entry of this.readResetEntries()) {
+      lastResetBySessionName.set(entry.sessionName, entry.resetEpochSeconds);
+    }
+    return lastResetBySessionName;
+  };
+
+  recordReset = async (params: {
+    sessionName: string;
+    now: Date;
+  }): Promise<void> => {
+    const resetEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      resetEpochSeconds - this.retentionWindowSeconds;
+    const mergedBySessionName = new Map<string, StoredResetEntry>();
+    for (const entry of this.readResetEntries()) {
+      if (
+        entry.resetEpochSeconds >= oldestRetainedEpochSeconds &&
+        entry.sessionName !== params.sessionName
+      ) {
+        mergedBySessionName.set(entry.sessionName, entry);
+      }
+    }
+    mergedBySessionName.set(params.sessionName, {
+      sessionName: params.sessionName,
+      resetEpochSeconds,
+    });
+    this.writeState(Array.from(mergedBySessionName.values()));
+  };
+
+  private readResetEntries = (): StoredResetEntry[] => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch {
+      return [];
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!isRecord(parsed)) {
+      return [];
+    }
+    const storedEntries = parsed.resets;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredResetEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const resetEpochSeconds = storedEntry.resetEpochSeconds;
+      if (
+        typeof sessionName === 'string' &&
+        typeof resetEpochSeconds === 'number' &&
+        Number.isFinite(resetEpochSeconds)
+      ) {
+        entries.push({ sessionName, resetEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeState = (resets: StoredResetEntry[]): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporaryPath, JSON.stringify({ resets }));
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}

package/src/domain/entities/OutputDegeneration.ts

@@ -0,0 +1,10 @@
+export type IntraTurnDegeneration = {
+  token: string;
+  run: number;
+  turnTokenCount: number;
+};
+
+export type CrossTurnDegeneration = {
+  token: string;
+  turnCount: number;
+};

package/src/domain/usecases/OutputDegenerationDetector.test.ts

@@ -0,0 +1,167 @@
+import {
+  OutputDegenerationDetector,
+  OUTPUT_DEGENERATION_REPEAT_THRESHOLD,
+  OUTPUT_DEGENERATION_DOMINATION_FRACTION,
+  OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH,
+  OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD,
+  OUTPUT_DEGENERATION_REP4_THRESHOLD,
+  OUTPUT_DEGENERATION_REP4_MIN_TOKENS,
+  OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+  OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS,
+} from './OutputDegenerationDetector';
+
+const repeat = (token: string, count: number): string =>
+  Array.from({ length: count }, () => token).join(' ');
+
+describe('OutputDegenerationDetector', () => {
+  const detector = new OutputDegenerationDetector();
+
+  describe('ported constants match the validated Python values', () => {
+    it('exposes the exact thresholds', () => {
+      expect(OUTPUT_DEGENERATION_REPEAT_THRESHOLD).toBe(5);
+      expect(OUTPUT_DEGENERATION_DOMINATION_FRACTION).toBe(0.8);
+      expect(OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH).toBe(32);
+      expect(OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD).toBe(15);
+      expect(OUTPUT_DEGENERATION_REP4_THRESHOLD).toBe(0.3);
+      expect(OUTPUT_DEGENERATION_REP4_MIN_TOKENS).toBe(40);
+      expect(OUTPUT_DEGENERATION_CROSS_TURN_WINDOW).toBe(10);
+      expect(OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS).toBe(4);
+    });
+  });
+
+  describe('isIntraTurnDegeneration', () => {
+    it('fires on a turn dominated by a single short repeated token (positive)', () => {
+      expect(detector.isIntraTurnDegeneration(repeat('court', 40))).toBe(true);
+    });
+
+    it('does not fire on a short run just below the repeat threshold (negative)', () => {
+      expect(detector.isIntraTurnDegeneration(repeat('court', 4))).toBe(false);
+    });
+
+    it('does not fire on healthy prose with no repetition', () => {
+      const healthy =
+        'I finished the migration and verified the results against the seed data. The build passed and the report is uploaded.';
+      expect(detector.isIntraTurnDegeneration(healthy)).toBe(false);
+    });
+
+    it('fires exactly at the domination-fraction boundary (run 5 of 6 tokens)', () => {
+      expect(
+        detector.isIntraTurnDegeneration('count count count count count alpha'),
+      ).toBe(true);
+    });
+
+    it('does not fire just past the domination-fraction boundary (run 5 of 7 tokens)', () => {
+      expect(
+        detector.isIntraTurnDegeneration(
+          'count count count count count alpha beta',
+        ),
+      ).toBe(false);
+    });
+
+    it('fires on a large absolute run even when domination fails', () => {
+      const buried = `${repeat('court', 15)} ${repeat('distinct', 1)} one two three four five`;
+      expect(detector.isIntraTurnDegeneration(buried)).toBe(true);
+    });
+
+    it('fires on a repeated phrase loop via duplicated 4-gram density', () => {
+      const phraseLoop = repeat('the quick brown fox', 15);
+      expect(detector.isIntraTurnDegeneration(phraseLoop)).toBe(true);
+    });
+
+    it('does not fire on a non-dominating repeat run confined to a fenced code block', () => {
+      const variedProse = Array.from(
+        { length: 100 },
+        (_unused, index) => `word${index}`,
+      ).join(' ');
+      const withCodeBlock = `${variedProse}\n\`\`\`\n${repeat('court', 20)}\n\`\`\``;
+      expect(detector.isIntraTurnDegeneration(withCodeBlock)).toBe(false);
+    });
+
+    it('ignores repeated long tokens above the max token length', () => {
+      const longToken = 'a'.repeat(OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH + 1);
+      expect(detector.isIntraTurnDegeneration(repeat(longToken, 40))).toBe(
+        false,
+      );
+    });
+
+    it('returns false for an empty turn', () => {
+      expect(detector.isIntraTurnDegeneration('')).toBe(false);
+    });
+  });
+
+  describe('maxConsecutiveShortTokenRun', () => {
+    it('reports the dominating token and run length for logging', () => {
+      const result = detector.maxConsecutiveShortTokenRun(repeat('court', 12));
+      expect(result.token).toBe('court');
+      expect(result.run).toBe(12);
+      expect(result.total).toBe(12);
+    });
+  });
+
+  describe('detectCrossTurnDegeneration', () => {
+    const cleanEnding = (index: number): string =>
+      `Turn ${index}: I completed the step and reported the result.`;
+    const trailingTokenTurn = (index: number, token: string): string =>
+      `Turn ${index}: real message here.\n\n${token}`;
+
+    it('fires when the same trailing token recurs in 4 of the last 10 turns', () => {
+      const turns = [
+        trailingTokenTurn(1, 'court'),
+        cleanEnding(2),
+        trailingTokenTurn(3, 'court'),
+        cleanEnding(4),
+        trailingTokenTurn(5, 'court'),
+        cleanEnding(6),
+        trailingTokenTurn(7, 'court'),
+        cleanEnding(8),
+        cleanEnding(9),
+        cleanEnding(10),
+      ];
+      const result = detector.detectCrossTurnDegeneration(turns);
+      expect(result).not.toBeNull();
+      expect(result?.token).toBe('court');
+      expect(result?.turnCount).toBe(4);
+    });
+
+    it('does not fire when the trailing token recurs in only 3 of 10 turns', () => {
+      const turns = [
+        trailingTokenTurn(1, 'court'),
+        cleanEnding(2),
+        trailingTokenTurn(3, 'court'),
+        cleanEnding(4),
+        trailingTokenTurn(5, 'court'),
+        cleanEnding(6),
+        cleanEnding(7),
+        cleanEnding(8),
+        cleanEnding(9),
+        cleanEnding(10),
+      ];
+      expect(detector.detectCrossTurnDegeneration(turns)).toBeNull();
+    });
+
+    it('does not treat a bare URL or multi-word ending as a trailing token', () => {
+      const turns = [
+        'Done. See https://example.com/report',
+        'The work is complete',
+        'Result: 42',
+        'Done. See https://example.com/report',
+      ];
+      expect(detector.detectCrossTurnDegeneration(turns)).toBeNull();
+    });
+
+    it('only counts turns inside the cross-turn window', () => {
+      const withinWindow = Array.from({ length: 10 }, (_unused, index) =>
+        index < 3 ? trailingTokenTurn(index, 'court') : cleanEnding(index),
+      );
+      const beyondWindow = Array.from({ length: 5 }, (_unused, index) =>
+        trailingTokenTurn(100 + index, 'court'),
+      );
+      expect(
+        detector.detectCrossTurnDegeneration([
+          ...withinWindow,
+          ...beyondWindow,
+        ]),
+      ).toBeNull();
+    });
+  });
+});

package/src/domain/usecases/OutputDegenerationDetector.ts

@@ -0,0 +1,169 @@
+import { CrossTurnDegeneration } from '../entities/OutputDegeneration';
+
+export const OUTPUT_DEGENERATION_REPEAT_THRESHOLD = 5;
+export const OUTPUT_DEGENERATION_DOMINATION_FRACTION = 0.8;
+export const OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH = 32;
+export const OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD = 15;
+export const OUTPUT_DEGENERATION_REP4_THRESHOLD = 0.3;
+export const OUTPUT_DEGENERATION_REP4_MIN_TOKENS = 40;
+export const OUTPUT_DEGENERATION_CROSS_TURN_WINDOW = 10;
+export const OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS = 4;
+
+export type ShortTokenRun = {
+  token: string | null;
+  run: number;
+  total: number;
+};
+
+const LIST_ITEM_LINE_PATTERN = /^\s*(?:[-*+]\s|\d+[.)]\s)/;
+const TRAILING_ALPHA_TOKEN_PATTERN = /^[A-Za-z]+$/;
+
+const splitTokens = (text: string): string[] =>
+  text.split(/\s+/).filter((token) => token.length > 0);
+
+const splitLines = (text: string): string[] => text.split(/\r\n|\r|\n/);
+
+export class OutputDegenerationDetector {
+  constructor(
+    private readonly repeatThreshold: number = OUTPUT_DEGENERATION_REPEAT_THRESHOLD,
+    private readonly dominationFraction: number = OUTPUT_DEGENERATION_DOMINATION_FRACTION,
+    private readonly maxTokenLength: number = OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH,
+    private readonly absoluteRunThreshold: number = OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD,
+    private readonly rep4Threshold: number = OUTPUT_DEGENERATION_REP4_THRESHOLD,
+    private readonly rep4MinTokens: number = OUTPUT_DEGENERATION_REP4_MIN_TOKENS,
+    private readonly crossTurnWindow: number = OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+    private readonly crossTurnMinTurns: number = OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS,
+  ) {}
+
+  maxConsecutiveShortTokenRun = (text: string): ShortTokenRun => {
+    let bestToken: string | null = null;
+    let bestRun = 0;
+    let totalTokens = 0;
+    let currentToken: string | null = null;
+    let currentRun = 0;
+    for (const token of splitTokens(text)) {
+      totalTokens += 1;
+      if (token.length > this.maxTokenLength) {
+        currentToken = null;
+        currentRun = 0;
+        continue;
+      }
+      if (token === currentToken) {
+        currentRun += 1;
+      } else {
+        currentToken = token;
+        currentRun = 1;
+      }
+      if (currentRun > bestRun) {
+        bestRun = currentRun;
+        bestToken = currentToken;
+      }
+    }
+    return { token: bestToken, run: bestRun, total: totalTokens };
+  };
+
+  isIntraTurnDegeneration = (text: string): boolean => {
+    const { run, total } = this.maxConsecutiveShortTokenRun(text);
+    if (total === 0) {
+      return false;
+    }
+    if (run >= this.repeatThreshold && run >= this.dominationFraction * total) {
+      return true;
+    }
+    const filtered = this.stripRepetitionExemptSpans(text);
+    const filteredRun = this.maxConsecutiveShortTokenRun(filtered);
+    if (filteredRun.run >= this.absoluteRunThreshold) {
+      return true;
+    }
+    if (
+      filteredRun.total >= this.rep4MinTokens &&
+      this.duplicateNgramFraction(filtered, 4) >= this.rep4Threshold
+    ) {
+      return true;
+    }
+    return false;
+  };
+
+  detectCrossTurnDegeneration = (
+    texts: string[],
+  ): CrossTurnDegeneration | null => {
+    const counts = new Map<string, number>();
+    for (const text of texts.slice(0, this.crossTurnWindow)) {
+      const token = this.trailingSpuriousToken(text);
+      if (token === null) {
+        continue;
+      }
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+    let bestToken: string | null = null;
+    let bestCount = 0;
+    for (const [token, count] of counts) {
+      if (count > bestCount) {
+        bestCount = count;
+        bestToken = token;
+      }
+    }
+    if (bestToken !== null && bestCount >= this.crossTurnMinTurns) {
+      return { token: bestToken, turnCount: bestCount };
+    }
+    return null;
+  };
+
+  private stripRepetitionExemptSpans = (text: string): string => {
+    const keptLines: string[] = [];
+    let inFence = false;
+    for (const line of splitLines(text)) {
+      const stripped = line.trim();
+      if (stripped.startsWith('```') || stripped.startsWith('~~~')) {
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence) {
+        continue;
+      }
+      if (line.includes('|')) {
+        continue;
+      }
+      if (LIST_ITEM_LINE_PATTERN.test(line)) {
+        continue;
+      }
+      keptLines.push(line);
+    }
+    return keptLines.join('\n');
+  };
+
+  private duplicateNgramFraction = (text: string, n: number): number => {
+    const tokens = splitTokens(text).filter(
+      (token) => token.length <= this.maxTokenLength,
+    );
+    if (tokens.length < n + 1) {
+      return 0;
+    }
+    const ngrams: string[] = [];
+    for (let index = 0; index <= tokens.length - n; index += 1) {
+      ngrams.push(tokens.slice(index, index + n).join('\u0000'));
+    }
+    const total = ngrams.length;
+    if (total < 2) {
+      return 0;
+    }
+    const unique = new Set(ngrams).size;
+    return 1 - unique / total;
+  };
+
+  private trailingSpuriousToken = (text: string): string | null => {
+    const stripped = text.replace(/\s+$/, '');
+    if (stripped.length === 0) {
+      return null;
+    }
+    const lines = splitLines(stripped);
+    const lastLine = lines[lines.length - 1].trim();
+    if (lastLine.length === 0 || lastLine.length > this.maxTokenLength) {
+      return null;
+    }
+    if (!TRAILING_ALPHA_TOKEN_PATTERN.test(lastLine)) {
+      return null;
+    }
+    return lastLine;
+  };
+}