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

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

@@ -1,324 +0,0 @@
-import { ConfigurableSilentSessionMessageComposer } from './ConfigurableSilentSessionMessageComposer';
-import { SilentSessionMessageComposer } from '../../domain/usecases/adapter-interfaces/SilentSessionMessageComposer';
-import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
-
-const createFallback = (): Mocked<SilentSessionMessageComposer> => ({
-  composeMainStalledSection: jest.fn().mockReturnValue('FALLBACK_MAIN'),
-  composeMainStalledWithStaleOwnerCallSection: jest
-    .fn()
-    .mockReturnValue('FALLBACK_STALE_OWNER_CALL'),
-  composeSubAgentSection: jest.fn().mockReturnValue('FALLBACK_SUB'),
-  composeSubAgentUnconsumedResultSection: jest
-    .fn()
-    .mockReturnValue('FALLBACK_UNCONSUMED_RESULT'),
-});
-
-const noTemplates = {
-  mainStalledMessage: null,
-  mainStalledStaleOwnerCallMessage: null,
-  subAgentIdleMessageHeader: null,
-  subAgentIdleMessageFooter: null,
-  subAgentLongRunningMessageHeader: null,
-  subAgentLongRunningMessageFooter: null,
-};
-
-describe('ConfigurableSilentSessionMessageComposer', () => {
-  it('uses the fallback main section when no main template is configured', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      noTemplates,
-      fallback,
-    );
-    expect(composer.composeMainStalledSection(600)).toBe('FALLBACK_MAIN');
-    expect(fallback.composeMainStalledSection).toHaveBeenCalledWith(600);
-  });
-
-  it('uses the configured main template when provided', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledMessage: 'CUSTOM_MAIN',
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledSection(600);
-    expect(section).toContain('CUSTOM_MAIN');
-    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
-    expect(fallback.composeMainStalledSection).not.toHaveBeenCalled();
-  });
-
-  it('appends no owner-call guidance and no self-diagnosis guidance to the configured main template', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledMessage: 'CUSTOM_MAIN',
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledSection(600);
-    expect(section).toContain('CUSTOM_MAIN');
-    expect(section).not.toContain('share it through a new owner-call');
-    expect(section).not.toContain('in the format documented for this session');
-    expect(section).not.toContain('written to be self-contained');
-    expect(section).not.toContain(
-      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
-    );
-    expect(section).not.toContain('re-raise');
-    expect(section).not.toContain('<');
-    expect(section).not.toContain('>');
-    expect(section).not.toMatch(
-      /[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]/u,
-    );
-    expect(section).not.toContain('\u{FE0F}');
-  });
-
-  it('omits the self-diagnosis guidance from the configured stale-owner-call template section', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledStaleOwnerCallMessage: 'CUSTOM_STALE',
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledWithStaleOwnerCallSection(
-      600,
-      3600,
-    );
-    expect(section).not.toContain(
-      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
-    );
-  });
-
-  it('uses the fallback stale-owner-call section when no stale-owner-call template is configured', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      noTemplates,
-      fallback,
-    );
-    expect(
-      composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
-    ).toBe('FALLBACK_STALE_OWNER_CALL');
-    expect(
-      fallback.composeMainStalledWithStaleOwnerCallSection,
-    ).toHaveBeenCalledWith(600, 3600);
-  });
-
-  it('uses the configured stale-owner-call template when provided', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledStaleOwnerCallMessage: 'CUSTOM_STALE_OWNER_CALL',
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledWithStaleOwnerCallSection(
-      600,
-      3600,
-    );
-    expect(section).toContain('CUSTOM_STALE_OWNER_CALL');
-    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
-    expect(section).toContain(
-      'share it through a new owner-call in the format documented for this session',
-    );
-    expect(section).not.toContain('marker tag');
-    expect(section).not.toContain('<');
-    expect(section).not.toContain('>');
-    expect(
-      fallback.composeMainStalledWithStaleOwnerCallSection,
-    ).not.toHaveBeenCalled();
-  });
-
-  it('uses the fallback sub-agent section when no sub-agent template is configured', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      noTemplates,
-      fallback,
-    );
-    const subAgent = {
-      label: 'task-a',
-      silentSeconds: 360,
-      runningSeconds: 1200,
-      waitingOnExternalProcess: false,
-      finishedResultUnconsumed: false,
-    };
-    expect(
-      composer.composeSubAgentSection({
-        idleSubAgents: [subAgent],
-        longRunningSubAgents: [subAgent],
-      }),
-    ).toBe('FALLBACK_SUB');
-    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith({
-      idleSubAgents: [subAgent],
-      longRunningSubAgents: [subAgent],
-    });
-  });
-
-  it('renders the configured idle header, list, and footer for an idle sub-agent', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        subAgentIdleMessageHeader: 'IDLE_HEADER',
-        subAgentIdleMessageFooter: 'IDLE_FOOTER',
-      },
-      fallback,
-    );
-    const section = composer.composeSubAgentSection({
-      idleSubAgents: [
-        {
-          label: 'task-a',
-          silentSeconds: 360,
-          runningSeconds: 60,
-          waitingOnExternalProcess: false,
-          finishedResultUnconsumed: false,
-        },
-      ],
-      longRunningSubAgents: [],
-    });
-    expect(section).toContain('IDLE_HEADER');
-    expect(section).toContain('task-a');
-    expect(section).toContain('no output for 6m');
-    expect(section).toContain('IDLE_FOOTER');
-    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
-    expect(fallback.composeSubAgentSection).not.toHaveBeenCalled();
-  });
-
-  it('renders the configured long-running header, list, and footer for a long-running sub-agent', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        subAgentLongRunningMessageHeader: 'LONG_HEADER',
-        subAgentLongRunningMessageFooter: 'LONG_FOOTER',
-      },
-      fallback,
-    );
-    const section = composer.composeSubAgentSection({
-      idleSubAgents: [],
-      longRunningSubAgents: [
-        {
-          label: 'task-b',
-          silentSeconds: 30,
-          runningSeconds: 1200,
-          waitingOnExternalProcess: false,
-          finishedResultUnconsumed: false,
-        },
-      ],
-    });
-    expect(section).toContain('LONG_HEADER');
-    expect(section).toContain('task-b');
-    expect(section).toContain('running for 20m');
-    expect(section).toContain('LONG_FOOTER');
-    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
-    expect(fallback.composeSubAgentSection).not.toHaveBeenCalled();
-  });
-
-  it('emits both distinct configured sections for a sub-agent matching both conditions', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        subAgentIdleMessageHeader: 'IDLE_HEADER',
-        subAgentLongRunningMessageHeader: 'LONG_HEADER',
-      },
-      fallback,
-    );
-    const subAgent = {
-      label: 'task-both',
-      silentSeconds: 360,
-      runningSeconds: 1200,
-      waitingOnExternalProcess: false,
-      finishedResultUnconsumed: false,
-    };
-    const section = composer.composeSubAgentSection({
-      idleSubAgents: [subAgent],
-      longRunningSubAgents: [subAgent],
-    });
-    const [idleSection, longRunningSection] = section
-      .replace(`${SILENT_SESSION_REMINDER_SENTINEL} `, '')
-      .split('\n\n');
-    expect(idleSection).toContain('IDLE_HEADER');
-    expect(idleSection).toContain('no output for 6m');
-    expect(longRunningSection).toContain('LONG_HEADER');
-    expect(longRunningSection).toContain('running for 20m');
-  });
-
-  it('renders the built-in idle message via the fallback when only a long-running template is configured', () => {
-    const fallback = createFallback();
-    fallback.composeSubAgentSection.mockReturnValue('BUILTIN_IDLE');
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        subAgentLongRunningMessageHeader: 'LONG_HEADER',
-      },
-      fallback,
-    );
-    const idleSubAgent = {
-      label: 'task-idle',
-      silentSeconds: 360,
-      runningSeconds: 60,
-      waitingOnExternalProcess: false,
-      finishedResultUnconsumed: false,
-    };
-    const section = composer.composeSubAgentSection({
-      idleSubAgents: [idleSubAgent],
-      longRunningSubAgents: [],
-    });
-    expect(section).toContain('BUILTIN_IDLE');
-    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith({
-      idleSubAgents: [idleSubAgent],
-      longRunningSubAgents: [],
-    });
-  });
-
-  it('delegates the unconsumed-result section to the fallback composer because no template governs it', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        subAgentIdleMessageHeader: 'CUSTOM_IDLE_HEADER',
-      },
-      fallback,
-    );
-    const unconsumedResultSubAgent = {
-      label: 'agent-aaabbbbcccc30001',
-      silentSeconds: 5220,
-      runningSeconds: 5400,
-      waitingOnExternalProcess: false,
-      finishedResultUnconsumed: true,
-    };
-
-    const section = composer.composeSubAgentUnconsumedResultSection([
-      unconsumedResultSubAgent,
-    ]);
-
-    expect(section).toBe('FALLBACK_UNCONSUMED_RESULT');
-    expect(
-      fallback.composeSubAgentUnconsumedResultSection,
-    ).toHaveBeenCalledWith([unconsumedResultSubAgent]);
-  });
-
-  it('does not double-prepend the sentinel when the template already carries it', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledMessage: `${SILENT_SESSION_REMINDER_SENTINEL} CUSTOM_MAIN`,
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledSection(600);
-    const sentinelOccurrences =
-      section.split(SILENT_SESSION_REMINDER_SENTINEL).length - 1;
-    expect(sentinelOccurrences).toBe(1);
-    expect(
-      section.startsWith(`${SILENT_SESSION_REMINDER_SENTINEL} CUSTOM_MAIN`),
-    ).toBe(true);
-  });
-});

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -1,148 +0,0 @@
-import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
-import { composeOwnerCallFormatGuidance } from '../../domain/usecases/DefaultSilentSessionMessageComposer';
-import {
-  SilentSessionMessageComposer,
-  SubAgentStallSections,
-} from '../../domain/usecases/adapter-interfaces/SilentSessionMessageComposer';
-import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
-
-const withReminderSentinel = (message: string): string =>
-  message.includes(SILENT_SESSION_REMINDER_SENTINEL)
-    ? message
-    : `${SILENT_SESSION_REMINDER_SENTINEL} ${message}`;
-
-export type SilentSessionMessageTemplates = {
-  mainStalledMessage: string | null;
-  mainStalledStaleOwnerCallMessage: string | null;
-  subAgentIdleMessageHeader: string | null;
-  subAgentIdleMessageFooter: string | null;
-  subAgentLongRunningMessageHeader: string | null;
-  subAgentLongRunningMessageFooter: string | null;
-};
-
-const formatMinutes = (seconds: number): string => {
-  const minutes = Math.floor(seconds / 60);
-  return `${minutes}m`;
-};
-
-export class ConfigurableSilentSessionMessageComposer implements SilentSessionMessageComposer {
-  constructor(
-    private readonly templates: SilentSessionMessageTemplates,
-    private readonly fallback: SilentSessionMessageComposer,
-  ) {}
-
-  composeMainStalledSection = (mainSilentSeconds: number): string => {
-    if (this.templates.mainStalledMessage === null) {
-      return this.fallback.composeMainStalledSection(mainSilentSeconds);
-    }
-    return withReminderSentinel(this.templates.mainStalledMessage);
-  };
-
-  composeMainStalledWithStaleOwnerCallSection = (
-    mainSilentSeconds: number,
-    unansweredOwnerCallAgeSeconds: number,
-  ): string => {
-    if (this.templates.mainStalledStaleOwnerCallMessage === null) {
-      return this.fallback.composeMainStalledWithStaleOwnerCallSection(
-        mainSilentSeconds,
-        unansweredOwnerCallAgeSeconds,
-      );
-    }
-    return withReminderSentinel(
-      `${this.templates.mainStalledStaleOwnerCallMessage} ${composeOwnerCallFormatGuidance()}`,
-    );
-  };
-
-  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
-    const hasIdleTemplate =
-      this.templates.subAgentIdleMessageHeader !== null ||
-      this.templates.subAgentIdleMessageFooter !== null;
-    const hasLongRunningTemplate =
-      this.templates.subAgentLongRunningMessageHeader !== null ||
-      this.templates.subAgentLongRunningMessageFooter !== null;
-    if (!hasIdleTemplate && !hasLongRunningTemplate) {
-      return this.fallback.composeSubAgentSection(stallSections);
-    }
-
-    const { idleSubAgents, longRunningSubAgents } = stallSections;
-
-    const sections: string[] = [];
-    if (idleSubAgents.length > 0 && hasIdleTemplate) {
-      sections.push(
-        this.composeIdleSection(
-          idleSubAgents,
-          this.templates.subAgentIdleMessageHeader,
-          this.templates.subAgentIdleMessageFooter,
-        ),
-      );
-    } else if (idleSubAgents.length > 0) {
-      sections.push(
-        this.fallback.composeSubAgentSection({
-          idleSubAgents,
-          longRunningSubAgents: [],
-        }),
-      );
-    }
-    if (longRunningSubAgents.length > 0 && hasLongRunningTemplate) {
-      sections.push(
-        this.composeLongRunningSection(
-          longRunningSubAgents,
-          this.templates.subAgentLongRunningMessageHeader,
-          this.templates.subAgentLongRunningMessageFooter,
-        ),
-      );
-    } else if (longRunningSubAgents.length > 0) {
-      sections.push(
-        this.composeLongRunningSection(longRunningSubAgents, null, null),
-      );
-    }
-    return withReminderSentinel(sections.join('\n\n'));
-  };
-
-  composeSubAgentUnconsumedResultSection = (
-    unconsumedResultSubAgents: SubAgentActivity[],
-  ): string =>
-    this.fallback.composeSubAgentUnconsumedResultSection(
-      unconsumedResultSubAgents,
-    );
-
-  private composeIdleSection = (
-    idleSubAgents: SubAgentActivity[],
-    header: string | null,
-    footer: string | null,
-  ): string => {
-    const lines = idleSubAgents.map(
-      (subAgent) =>
-        `- ${subAgent.label}: no output for ${formatMinutes(subAgent.silentSeconds)}`,
-    );
-    const parts: string[] = [];
-    if (header !== null) {
-      parts.push(header);
-    }
-    parts.push(...lines);
-    if (footer !== null) {
-      parts.push(footer);
-    }
-    return parts.join('\n');
-  };
-
-  private composeLongRunningSection = (
-    longRunningSubAgents: SubAgentActivity[],
-    header: string | null,
-    footer: string | null,
-  ): string => {
-    const lines = longRunningSubAgents.map(
-      (subAgent) =>
-        `- ${subAgent.label}: running for ${formatMinutes(subAgent.runningSeconds)}`,
-    );
-    const parts: string[] = [];
-    if (header !== null) {
-      parts.push(header);
-    }
-    parts.push(...lines);
-    if (footer !== null) {
-      parts.push(footer);
-    }
-    return parts.join('\n');
-  };
-}

package/src/adapter/repositories/FetchWebhookRepository.ts

@@ -1,8 +0,0 @@
-import ky from 'ky';
-import { WebhookRepository } from '../../domain/usecases/adapter-interfaces/WebhookRepository';
-
-export class FetchWebhookRepository implements WebhookRepository {
-  async sendGetRequest(url: string): Promise<void> {
-    await ky.get(url);
-  }
-}

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

@@ -1,114 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  FileHandoverStateRepository,
-  defaultHandoverStateFilePath,
-} from './FileHandoverStateRepository';
-
-describe('FileHandoverStateRepository', () => {
-  let directory: string;
-  let filePath: string;
-
-  beforeEach(() => {
-    directory = fs.mkdtempSync(path.join(os.tmpdir(), 'handover-state-'));
-    filePath = path.join(directory, 'nested', 'state.json');
-  });
-
-  afterEach(() => {
-    fs.rmSync(directory, { recursive: true, force: true });
-  });
-
-  it('returns an empty state when the file does not exist', () => {
-    const repository = new FileHandoverStateRepository(filePath);
-
-    expect(repository.load()).toEqual({ entries: {} });
-  });
-
-  it('saves and reloads state, creating parent directories', () => {
-    const repository = new FileHandoverStateRepository(filePath);
-    const state = {
-      entries: {
-        'session-a': { signaledAtEpoch: 1700000000, pid: 4242 },
-      },
-    };
-
-    repository.save(state);
-
-    expect(fs.existsSync(filePath)).toBe(true);
-    expect(new FileHandoverStateRepository(filePath).load()).toEqual(state);
-  });
-
-  it('writes atomically via a temporary file and leaves no temp file behind', () => {
-    const repository = new FileHandoverStateRepository(filePath);
-
-    repository.save({
-      entries: { 'session-a': { signaledAtEpoch: 1, pid: 2 } },
-    });
-
-    expect(fs.existsSync(`${filePath}.tmp`)).toBe(false);
-  });
-
-  it('returns an empty state when the file contains invalid JSON', () => {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, 'not json');
-    const repository = new FileHandoverStateRepository(filePath);
-
-    expect(repository.load()).toEqual({ entries: {} });
-  });
-
-  it('drops entries with malformed values while keeping valid ones', () => {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(
-      filePath,
-      JSON.stringify({
-        entries: {
-          valid: { signaledAtEpoch: 5, pid: 6 },
-          missingPid: { signaledAtEpoch: 5 },
-          notAnObject: 7,
-        },
-      }),
-    );
-    const repository = new FileHandoverStateRepository(filePath);
-
-    expect(repository.load()).toEqual({
-      entries: { valid: { signaledAtEpoch: 5, pid: 6 } },
-    });
-  });
-});
-
-describe('defaultHandoverStateFilePath', () => {
-  const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-
-  afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-      delete process.env.XDG_CACHE_HOME;
-    } else {
-      process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-  });
-
-  it('uses a TDPM-native filename distinct from the standalone monitor state file', () => {
-    process.env.XDG_CACHE_HOME = '/custom/cache';
-
-    expect(defaultHandoverStateFilePath()).toBe(
-      '/custom/cache/tdpm/token-exhaustion-handover-state-tdpm-native.json',
-    );
-    expect(defaultHandoverStateFilePath()).not.toBe(
-      '/custom/cache/tdpm/token-exhaustion-handover-state.json',
-    );
-  });
-
-  it('falls back to ~/.cache when XDG_CACHE_HOME is unset', () => {
-    delete process.env.XDG_CACHE_HOME;
-
-    expect(defaultHandoverStateFilePath()).toBe(
-      path.join(
-        os.homedir(),
-        '.cache',
-        'tdpm',
-        'token-exhaustion-handover-state-tdpm-native.json',
-      ),
-    );
-  });
-});

package/src/adapter/repositories/FileHandoverStateRepository.ts

@@ -1,73 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  TokenExhaustionHandoverState,
-  TokenExhaustionHandoverStateEntry,
-} from '../../domain/entities/TokenExhaustionHandoverState';
-import { TokenExhaustionHandoverStateRepository } from '../../domain/usecases/adapter-interfaces/TokenExhaustionHandoverStateRepository';
-import { tdpmCacheDirectory } from './localStorageCacheDirectory';
-
-export const defaultHandoverStateFilePath = (): string =>
-  path.join(
-    tdpmCacheDirectory(),
-    'token-exhaustion-handover-state-tdpm-native.json',
-  );
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-export class FileHandoverStateRepository implements TokenExhaustionHandoverStateRepository {
-  constructor(
-    private readonly filePath: string = defaultHandoverStateFilePath(),
-  ) {}
-
-  load = (): TokenExhaustionHandoverState => {
-    let raw: string;
-    try {
-      raw = fs.readFileSync(this.filePath, 'utf8');
-    } catch {
-      return { entries: {} };
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return { entries: {} };
-    }
-    return { entries: this.parseEntries(parsed) };
-  };
-
-  save = (state: TokenExhaustionHandoverState): void => {
-    const directory = path.dirname(this.filePath);
-    if (!fs.existsSync(directory)) {
-      fs.mkdirSync(directory, { recursive: true });
-    }
-    const temporaryPath = `${this.filePath}.tmp`;
-    fs.writeFileSync(temporaryPath, JSON.stringify(state));
-    fs.renameSync(temporaryPath, this.filePath);
-  };
-
-  private parseEntries = (
-    parsed: unknown,
-  ): Record<string, TokenExhaustionHandoverStateEntry> => {
-    const entries: Record<string, TokenExhaustionHandoverStateEntry> = {};
-    if (!isRecord(parsed)) {
-      return entries;
-    }
-    const stored = parsed.entries;
-    if (!isRecord(stored)) {
-      return entries;
-    }
-    for (const [key, value] of Object.entries(stored)) {
-      if (!isRecord(value)) {
-        continue;
-      }
-      const signaledAtEpoch = value.signaledAtEpoch;
-      const pid = value.pid;
-      if (typeof signaledAtEpoch === 'number' && typeof pid === 'number') {
-        entries[key] = { signaledAtEpoch, pid };
-      }
-    }
-    return entries;
-  };
-}