github-issue-tower-defence-management 1.117.10 → 1.118.1

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

@@ -4,20 +4,29 @@ import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSe
 
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
+const THRESHOLDS = {
+  subAgentSilentThresholdSeconds: 300,
+  subAgentRunningThresholdSeconds: 900,
+};
+
 const createFallback = (): Mocked<SilentSessionMessageComposer> => ({
   composeMainStalledSection: jest.fn().mockReturnValue('FALLBACK_MAIN'),
   composeSubAgentSection: jest.fn().mockReturnValue('FALLBACK_SUB'),
 });
 
+const noTemplates = {
+  mainStalledMessage: 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(
-      {
-        mainStalledMessage: null,
-        subAgentMessageHeader: null,
-        subAgentMessageFooter: null,
-      },
+      noTemplates,
       fallback,
     );
     expect(composer.composeMainStalledSection(600)).toBe('FALLBACK_MAIN');
@@ -28,9 +37,8 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(
       {
+        ...noTemplates,
         mainStalledMessage: 'CUSTOM_MAIN',
-        subAgentMessageHeader: null,
-        subAgentMessageFooter: null,
       },
       fallback,
     );
@@ -40,52 +48,97 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     expect(fallback.composeMainStalledSection).not.toHaveBeenCalled();
   });
 
-  it('uses the fallback sub-agent section when neither header nor footer is configured', () => {
+  it('uses the fallback sub-agent section when no sub-agent template is configured', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        mainStalledMessage: null,
-        subAgentMessageHeader: null,
-        subAgentMessageFooter: null,
-      },
+      noTemplates,
       fallback,
     );
     expect(
-      composer.composeSubAgentSection([
-        { label: 'task-a', silentSeconds: 360, runningSeconds: 1200 },
-      ]),
+      composer.composeSubAgentSection(
+        [{ label: 'task-a', silentSeconds: 360, runningSeconds: 1200 }],
+        THRESHOLDS,
+      ),
     ).toBe('FALLBACK_SUB');
+    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith(
+      [{ label: 'task-a', silentSeconds: 360, runningSeconds: 1200 }],
+      THRESHOLDS,
+    );
   });
 
-  it('renders the configured sub-agent header, list, and footer', () => {
+  it('renders the configured idle header, list, and footer for an idle sub-agent', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(
       {
-        mainStalledMessage: null,
-        subAgentMessageHeader: 'HEADER',
-        subAgentMessageFooter: 'FOOTER',
+        ...noTemplates,
+        subAgentIdleMessageHeader: 'IDLE_HEADER',
+        subAgentIdleMessageFooter: 'IDLE_FOOTER',
       },
       fallback,
     );
-    const section = composer.composeSubAgentSection([
-      { label: 'task-a', silentSeconds: 360, runningSeconds: 1200 },
-    ]);
-    expect(section).toContain('HEADER');
+    const section = composer.composeSubAgentSection(
+      [{ label: 'task-a', silentSeconds: 360, runningSeconds: 60 }],
+      THRESHOLDS,
+    );
+    expect(section).toContain('IDLE_HEADER');
     expect(section).toContain('task-a');
-    expect(section).toContain('silent for 6m');
+    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(
+      [{ label: 'task-b', silentSeconds: 30, runningSeconds: 1200 }],
+      THRESHOLDS,
+    );
+    expect(section).toContain('LONG_HEADER');
+    expect(section).toContain('task-b');
     expect(section).toContain('running for 20m');
-    expect(section).toContain('FOOTER');
+    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 section = composer.composeSubAgentSection(
+      [{ label: 'task-both', silentSeconds: 360, runningSeconds: 1200 }],
+      THRESHOLDS,
+    );
+    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('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`,
-        subAgentMessageHeader: null,
-        subAgentMessageFooter: null,
       },
       fallback,
     );

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -1,5 +1,8 @@
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
-import { SilentSessionMessageComposer } from '../../domain/usecases/adapter-interfaces/SilentSessionMessageComposer';
+import {
+  SilentSessionMessageComposer,
+  SubAgentStallThresholds,
+} from '../../domain/usecases/adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
 
 const withReminderSentinel = (message: string): string =>
@@ -9,8 +12,10 @@ const withReminderSentinel = (message: string): string =>
 
 export type SilentSessionMessageTemplates = {
   mainStalledMessage: string | null;
-  subAgentMessageHeader: string | null;
-  subAgentMessageFooter: string | null;
+  subAgentIdleMessageHeader: string | null;
+  subAgentIdleMessageFooter: string | null;
+  subAgentLongRunningMessageHeader: string | null;
+  subAgentLongRunningMessageFooter: string | null;
 };
 
 const formatMinutes = (seconds: number): string => {
@@ -31,27 +36,94 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
     return withReminderSentinel(this.templates.mainStalledMessage);
   };
 
-  composeSubAgentSection = (subAgents: SubAgentActivity[]): string => {
-    if (
-      this.templates.subAgentMessageHeader === null &&
-      this.templates.subAgentMessageFooter === null
-    ) {
-      return this.fallback.composeSubAgentSection(subAgents);
+  composeSubAgentSection = (
+    subAgents: SubAgentActivity[],
+    thresholds: SubAgentStallThresholds,
+  ): 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(subAgents, thresholds);
     }
-    const lines = subAgents.map(
+
+    const idleSubAgents = subAgents.filter(
+      (subAgent) =>
+        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
+    );
+    const longRunningSubAgents = subAgents.filter(
       (subAgent) =>
-        `- ${subAgent.label}: silent for ${formatMinutes(
-          subAgent.silentSeconds,
-        )}, running for ${formatMinutes(subAgent.runningSeconds)}`,
+        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
     );
+
     const sections: string[] = [];
-    if (this.templates.subAgentMessageHeader !== null) {
-      sections.push(this.templates.subAgentMessageHeader);
+    if (idleSubAgents.length > 0 && hasIdleTemplate) {
+      sections.push(
+        this.composeIdleSection(
+          idleSubAgents,
+          this.templates.subAgentIdleMessageHeader,
+          this.templates.subAgentIdleMessageFooter,
+        ),
+      );
+    } else if (idleSubAgents.length > 0) {
+      sections.push(this.composeIdleSection(idleSubAgents, null, null));
+    }
+    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'));
+  };
+
+  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);
     }
-    sections.push(...lines);
-    if (this.templates.subAgentMessageFooter !== null) {
-      sections.push(this.templates.subAgentMessageFooter);
+    parts.push(...lines);
+    if (footer !== null) {
+      parts.push(footer);
     }
-    return withReminderSentinel(sections.join('\n'));
+    return parts.join('\n');
   };
 }

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

@@ -0,0 +1,251 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
+  FileSystemSilentSessionHubTaskStatusCacheRepository,
+} from './FileSystemSilentSessionHubTaskStatusCacheRepository';
+
+describe('FileSystemSilentSessionHubTaskStatusCacheRepository', () => {
+  let rootDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'silent-session-hub-task-status-'),
+    );
+    stateFilePath = path.join(
+      rootDirectory,
+      'silent-session-hub-task-status.json',
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const issueAlpha = 'https://github.com/HiromiShikata/repo/issues/100';
+  const issueBravo = 'https://github.com/HiromiShikata/repo/issues/200';
+
+  it('round-trips a saved status so the next cycle reads it back', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now,
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toEqual({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
+    });
+  });
+
+  it('preserves a null project status across a round-trip', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: null,
+      now,
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toEqual({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: null,
+      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
+    });
+  });
+
+  it('returns null when no status has been recorded for the url', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toBeNull();
+  });
+
+  it('returns null when no state file exists yet', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      path.join(rootDirectory, 'missing.json'),
+    );
+
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toBeNull();
+  });
+
+  it('returns the most recently recorded status when a url is saved again', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: 'Done',
+      now: new Date('2026-06-26T00:01:00Z'),
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded?.state).toBe('CLOSED');
+    expect(loaded?.status).toBe('Done');
+  });
+
+  it('preserves another url recorded by a concurrent run when saving a different url', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueBravo,
+      state: 'CLOSED',
+      status: 'Done',
+      now: new Date('2026-06-26T00:00:30Z'),
+    });
+
+    expect(
+      (await repository.loadHubTaskStatus({ url: issueAlpha }))?.state,
+    ).toBe('OPEN');
+    expect(
+      (await repository.loadHubTaskStatus({ url: issueBravo }))?.state,
+    ).toBe('CLOSED');
+  });
+
+  it('drops a stored entry that has aged beyond the retention window on the next save', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+      60 * 60,
+    );
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueBravo,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T01:30:00Z'),
+    });
+
+    const persisted: unknown = JSON.parse(
+      fs.readFileSync(stateFilePath, 'utf8'),
+    );
+    expect(persisted).toEqual({
+      hubTaskStatuses: [
+        {
+          url: issueBravo,
+          state: 'OPEN',
+          status: 'In tmux',
+          recordedEpochSeconds: Math.floor(
+            new Date('2026-06-26T01:30:00Z').getTime() / 1000,
+          ),
+        },
+      ],
+    });
+  });
+
+  it('treats a corrupt state file as no recorded status', async () => {
+    fs.writeFileSync(stateFilePath, 'not valid json');
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toBeNull();
+  });
+
+  it('ignores a malformed stored entry that lacks a valid state', async () => {
+    fs.writeFileSync(
+      stateFilePath,
+      JSON.stringify({
+        hubTaskStatuses: [
+          {
+            url: issueAlpha,
+            state: 'UNKNOWN',
+            status: 'In tmux',
+            recordedEpochSeconds: 1,
+          },
+        ],
+      }),
+    );
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+
+    expect(loaded).toBeNull();
+  });
+
+  it('creates the parent directory when the configured path does not exist yet', async () => {
+    const nestedPath = path.join(rootDirectory, 'nested', 'dir', 'state.json');
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      nestedPath,
+    );
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+
+    expect(fs.existsSync(nestedPath)).toBe(true);
+  });
+
+  it('writes atomically by renaming a temp file into place leaving no temp file behind', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+
+    const leftoverTempFiles = fs
+      .readdirSync(rootDirectory)
+      .filter((name) => name.includes('.tmp'));
+    expect(leftoverTempFiles).toEqual([]);
+    expect(fs.existsSync(stateFilePath)).toBe(true);
+  });
+
+  it('exposes the default retention window as a named constant', () => {
+    expect(DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
+  });
+});

package/src/adapter/repositories/FileSystemSilentSessionHubTaskStatusCacheRepository.ts

@@ -0,0 +1,121 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Issue } from '../../domain/entities/Issue';
+import {
+  SilentSessionHubTaskStatusCacheEntry,
+  SilentSessionHubTaskStatusCacheRepository,
+} from '../../domain/usecases/adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const isIssueState = (value: unknown): value is Issue['state'] =>
+  value === 'OPEN' || value === 'CLOSED' || value === 'MERGED';
+
+export const DEFAULT_HUB_TASK_STATUS_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', 'silent-session-hub-task-status.json');
+};
+
+export class FileSystemSilentSessionHubTaskStatusCacheRepository implements SilentSessionHubTaskStatusCacheRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
+  ) {}
+
+  loadHubTaskStatus = async (params: {
+    url: string;
+  }): Promise<SilentSessionHubTaskStatusCacheEntry | null> => {
+    for (const entry of this.readEntries()) {
+      if (entry.url === params.url) {
+        return entry;
+      }
+    }
+    return null;
+  };
+
+  saveHubTaskStatus = async (params: {
+    url: string;
+    state: Issue['state'];
+    status: string | null;
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      recordedEpochSeconds - this.retentionWindowSeconds;
+    const mergedByUrl = new Map<string, SilentSessionHubTaskStatusCacheEntry>();
+    for (const entry of this.readEntries()) {
+      if (
+        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
+        entry.url !== params.url
+      ) {
+        mergedByUrl.set(entry.url, entry);
+      }
+    }
+    mergedByUrl.set(params.url, {
+      url: params.url,
+      state: params.state,
+      status: params.status,
+      recordedEpochSeconds,
+    });
+    this.writeEntries(Array.from(mergedByUrl.values()));
+  };
+
+  private readEntries = (): SilentSessionHubTaskStatusCacheEntry[] => {
+    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.hubTaskStatuses;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: SilentSessionHubTaskStatusCacheEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const url = storedEntry.url;
+      const state = storedEntry.state;
+      const status = storedEntry.status;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      if (
+        typeof url === 'string' &&
+        isIssueState(state) &&
+        (typeof status === 'string' || status === null) &&
+        typeof recordedEpochSeconds === 'number' &&
+        Number.isFinite(recordedEpochSeconds)
+      ) {
+        entries.push({ url, state, status, recordedEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeEntries = (
+    entries: SilentSessionHubTaskStatusCacheEntry[],
+  ): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(
+      temporaryPath,
+      JSON.stringify({ hubTaskStatuses: entries }),
+    );
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}