github-issue-tower-defence-management 1.120.0 → 1.121.0

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

@@ -53,17 +53,23 @@ describe('writeMachineStatus', () => {
     fs.rmSync(procDirectory, { recursive: true, force: true });
   });
 
-  it('writes machine-status.json with mem, cpu, disk, load and cycle minutes', async () => {
+  it('writes machine-status.json with mem, cpu, disk, load and cycle minutes derived from lastFetchedAt', async () => {
     const { repository } = buildHostMetricsRepository(procDirectory);
     const cacheDir = path.join(dir, 'allIssues-PVT');
     fs.mkdirSync(cacheDir, { recursive: true });
-    const newer = path.join(cacheDir, 'a.json');
-    const older = path.join(cacheDir, 'b.json');
-    fs.writeFileSync(older, '[]');
-    fs.writeFileSync(newer, '[]');
-    const base = Date.now();
-    fs.utimesSync(older, new Date(base - 900000), new Date(base - 900000));
-    fs.utimesSync(newer, new Date(base), new Date(base));
+    fs.writeFileSync(
+      path.join(cacheDir, 'latest.json'),
+      JSON.stringify({
+        lastFetchedAt: '2026-06-26T12:00:00.000Z',
+        lastFullFetchAt: '2026-06-26T11:00:00.000Z',
+        project: {},
+        issues: [],
+      }),
+    );
+    fs.writeFileSync(
+      path.join(dir, 'machine-status.json'),
+      JSON.stringify({ lastFetchedAt: '2026-06-26T11:45:00.000Z' }),
+    );
 
     await writeMachineStatus({
       dashboardDataDir: dir,
@@ -79,16 +85,25 @@ describe('writeMachineStatus', () => {
       diskPct: 90,
       load: [1.5, 0.8, 0.4],
       cycleMinutes: 15,
+      lastFetchedAt: '2026-06-26T12:00:00.000Z',
       capturedAt: '2026-06-26T12:00:00.000Z',
     };
     expect(written).toEqual(expected);
   });
 
-  it('writes cycleMinutes null when fewer than two cache files exist', async () => {
+  it('writes cycleMinutes null when there is no previous machine-status', async () => {
     const { repository } = buildHostMetricsRepository(procDirectory);
     const cacheDir = path.join(dir, 'allIssues-PVT');
     fs.mkdirSync(cacheDir, { recursive: true });
-    fs.writeFileSync(path.join(cacheDir, 'only.json'), '[]');
+    fs.writeFileSync(
+      path.join(cacheDir, 'latest.json'),
+      JSON.stringify({
+        lastFetchedAt: '2026-06-26T12:00:00.000Z',
+        lastFullFetchAt: '2026-06-26T11:00:00.000Z',
+        project: {},
+        issues: [],
+      }),
+    );
 
     await writeMachineStatus({
       dashboardDataDir: dir,
@@ -97,7 +112,10 @@ describe('writeMachineStatus', () => {
     });
 
     const written = readJson(path.join(dir, 'machine-status.json'));
-    expect(written).toMatchObject({ cycleMinutes: null });
+    expect(written).toMatchObject({
+      cycleMinutes: null,
+      lastFetchedAt: '2026-06-26T12:00:00.000Z',
+    });
   });
 
   it('is a no-op when dashboardDataDir is unset', async () => {

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

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import {
   ProcHostMetricsRepository,
-  cycleMinutesFromMtimes,
+  cycleMinutesFromFetchTimestamps,
 } from '../../repositories/ProcHostMetricsRepository';
 
 export type MachineStatusWriterParams = {
@@ -18,6 +18,7 @@ export type MachineStatusFile = {
   diskPct: number;
   load: [number, number, number];
   cycleMinutes: number | null;
+  lastFetchedAt: string | null;
   capturedAt: string;
 };
 
@@ -29,24 +30,26 @@ const writeJsonAtomic = (filePath: string, data: unknown): void => {
   fs.renameSync(tmpPath, filePath);
 };
 
-const cacheFileMtimesDescending = (allIssuesCacheDir: string): number[] => {
-  let entries: string[];
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const readLastFetchedAtFromJsonFile = (filePath: string): string | null => {
+  let raw: string;
   try {
-    entries = fs.readdirSync(allIssuesCacheDir);
+    raw = fs.readFileSync(filePath, 'utf8');
   } catch {
-    return [];
+    return null;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (isRecord(parsed) && typeof parsed.lastFetchedAt === 'string') {
+    return parsed.lastFetchedAt;
   }
-  return entries
-    .filter((entry) => entry.endsWith('.json'))
-    .map((entry) => {
-      try {
-        return fs.statSync(path.join(allIssuesCacheDir, entry)).mtimeMs / 1000;
-      } catch {
-        return null;
-      }
-    })
-    .filter((value): value is number => value !== null)
-    .sort((a, b) => b - a);
+  return null;
 };
 
 export const writeMachineStatus = async (
@@ -65,9 +68,16 @@ export const writeMachineStatus = async (
   const diskPct = hostMetricsRepository.readDiskUsedPercent();
   const load = hostMetricsRepository.readLoadAverages();
 
-  const cycleMinutes = allIssuesCacheDir
-    ? cycleMinutesFromMtimes(cacheFileMtimesDescending(allIssuesCacheDir))
+  const machineStatusPath = path.join(dashboardDataDir, 'machine-status.json');
+  const previousLastFetchedAt =
+    readLastFetchedAtFromJsonFile(machineStatusPath);
+  const currentLastFetchedAt = allIssuesCacheDir
+    ? readLastFetchedAtFromJsonFile(path.join(allIssuesCacheDir, 'latest.json'))
     : null;
+  const cycleMinutes = cycleMinutesFromFetchTimestamps(
+    previousLastFetchedAt,
+    currentLastFetchedAt,
+  );
 
   const file: MachineStatusFile = {
     memPct,
@@ -75,8 +85,9 @@ export const writeMachineStatus = async (
     diskPct,
     load: [load.oneMinute, load.fiveMinute, load.fifteenMinute],
     cycleMinutes,
+    lastFetchedAt: currentLastFetchedAt,
     capturedAt: (params.now ?? new Date()).toISOString(),
   };
 
-  writeJsonAtomic(path.join(dashboardDataDir, 'machine-status.json'), file);
+  writeJsonAtomic(machineStatusPath, file);
 };

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

@@ -56,7 +56,6 @@ const baseParams = {
   config: {
     maximumPreparingIssuesCount: 6,
     utilizationPercentageThreshold: 90,
-    allowIssueCacheMinutes: 5,
     thresholdForAutoReject: 3,
   },
 };
@@ -355,10 +354,6 @@ describe('writeSituationFile', () => {
         expect.any(String),
         expect.stringContaining('"utilizationPercentageThreshold":90'),
       );
-      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.stringContaining('"allowIssueCacheMinutes":5'),
-      );
       expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
         expect.any(String),
         expect.stringContaining('"thresholdForAutoReject":3'),

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

@@ -15,7 +15,6 @@ export type SituationFileParams = {
   config: {
     maximumPreparingIssuesCount: number | null;
     utilizationPercentageThreshold: number;
-    allowIssueCacheMinutes: number;
     thresholdForAutoReject: number;
   };
   preparationProcessCheckCommand?: string | null;

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

@@ -7,8 +7,6 @@ import { cleanStaleTmuxSessions } from './staleTmuxSessionCleaner';
 
 const NOW = new Date('2026-06-26T00:00:00.000Z');
 const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
-const ALLOW_CACHE_MINUTES = 10;
-
 const makeProject = (): Project => ({
   id: 'project-1',
   url: 'https://github.com/users/user/projects/1',
@@ -91,7 +89,6 @@ describe('cleanStaleTmuxSessions', () => {
 
     await cleanStaleTmuxSessions({
       project: makeProject(),
-      allowCacheMinutes: ALLOW_CACHE_MINUTES,
       issueRepository: createMockIssueRepository([
         makeIssue({ status: 'In Progress' }),
       ]),
@@ -124,7 +121,6 @@ describe('cleanStaleTmuxSessions', () => {
 
     await cleanStaleTmuxSessions({
       project: makeProject(),
-      allowCacheMinutes: ALLOW_CACHE_MINUTES,
       issueRepository: createMockIssueRepository([
         makeIssue({ status: IN_TMUX_STATUS_NAME }),
       ]),
@@ -155,7 +151,6 @@ describe('cleanStaleTmuxSessions', () => {
 
     await cleanStaleTmuxSessions({
       project: makeProject(),
-      allowCacheMinutes: ALLOW_CACHE_MINUTES,
       issueRepository: createMockIssueRepository([]),
       localCommandRunner: runner,
       now: NOW,

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

@@ -10,7 +10,6 @@ import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRep
 
 export type CleanStaleTmuxSessionsParams = {
   project: Project;
-  allowCacheMinutes: number;
   issueRepository: Pick<IssueRepository, 'getAllOpened'>;
   localCommandRunner: LocalCommandRunner;
   now: Date;
@@ -19,20 +18,13 @@ export type CleanStaleTmuxSessionsParams = {
 export const cleanStaleTmuxSessions = async (
   params: CleanStaleTmuxSessionsParams,
 ): Promise<void> => {
-  const {
-    project,
-    allowCacheMinutes,
-    issueRepository,
-    localCommandRunner,
-    now,
-  } = params;
+  const { project, issueRepository, localCommandRunner, now } = params;
   const useCase = new StaleTmuxSessionKillUseCase(
     issueRepository,
     new NodeTmuxSessionRepository(localCommandRunner),
   );
   await useCase.run({
     project,
-    allowCacheMinutes,
     excludedStatus: DEFAULT_EXCLUDED_STATUS,
     idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
     now,

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

@@ -177,4 +177,79 @@ describe('LocalStorageCacheRepository', () => {
       expect(callOrder).toEqual(['write', 'rename']);
     });
   });
+
+  describe('getSingle', () => {
+    test('returns null when latest.json does not exist', async () => {
+      localStorageRepository.listFiles.mockReturnValue([]);
+
+      const result = await repository.getSingle('test-key');
+
+      expect(result).toBeNull();
+      expect(localStorageRepository.read).not.toHaveBeenCalled();
+    });
+
+    test('returns null when the file content is empty', async () => {
+      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
+      localStorageRepository.read.mockReturnValue(null);
+
+      const result = await repository.getSingle('test-key');
+
+      expect(result).toBeNull();
+    });
+
+    test('returns null when the file content is invalid JSON', async () => {
+      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
+      localStorageRepository.read.mockReturnValue('not-json');
+
+      const result = await repository.getSingle('test-key');
+
+      expect(result).toBeNull();
+    });
+
+    test('returns the parsed value from latest.json', async () => {
+      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
+      localStorageRepository.read.mockReturnValue('{"lastFetchedAt":"x"}');
+
+      const result = await repository.getSingle('test-key');
+
+      expect(result).toEqual({ lastFetchedAt: 'x' });
+      expect(localStorageRepository.read).toHaveBeenCalledWith(
+        './tmp/cache/test-key/latest.json',
+      );
+    });
+  });
+
+  describe('setSingle', () => {
+    test('atomically writes a temp file then renames it to latest.json', async () => {
+      await repository.setSingle('test-key', { test: 'value' });
+
+      expect(localStorageRepository.mkdir).toHaveBeenCalledWith(
+        './tmp/cache/test-key',
+      );
+      const writeArgs = localStorageRepository.write.mock.calls[0];
+      const writtenPath = writeArgs[0];
+      const finalPath = './tmp/cache/test-key/latest.json';
+      expect(writtenPath.startsWith(`${finalPath}.`)).toBe(true);
+      expect(writtenPath.endsWith('.tmp')).toBe(true);
+      expect(writeArgs[1]).toBe('{"test":"value"}');
+      expect(localStorageRepository.rename).toHaveBeenCalledWith(
+        writtenPath,
+        finalPath,
+      );
+    });
+
+    test('writes to the temp file before renaming it into place', async () => {
+      const callOrder: string[] = [];
+      localStorageRepository.write.mockImplementation(() => {
+        callOrder.push('write');
+      });
+      localStorageRepository.rename.mockImplementation(() => {
+        callOrder.push('rename');
+      });
+
+      await repository.setSingle('ordering-key', { ordered: true });
+
+      expect(callOrder).toEqual(['write', 'rename']);
+    });
+  });
 });

package/src/adapter/repositories/LocalStorageCacheRepository.ts

@@ -51,4 +51,28 @@ export class LocalStorageCacheRepository {
     this.localStorageRepository.write(tmpPath, JSON.stringify(value));
     this.localStorageRepository.rename(tmpPath, finalPath);
   };
+  getSingle = async (key: string): Promise<unknown> => {
+    const dirPath = `${this.cachePath}/${key}`;
+    const fileName = 'latest.json';
+    if (!this.localStorageRepository.listFiles(dirPath).includes(fileName)) {
+      return null;
+    }
+    const valueStr = this.localStorageRepository.read(`${dirPath}/${fileName}`);
+    if (!valueStr) {
+      return null;
+    }
+    try {
+      return JSON.parse(valueStr);
+    } catch {
+      return null;
+    }
+  };
+  setSingle = async <T>(key: string, value: T): Promise<void> => {
+    const dirPath = `${this.cachePath}/${key}`;
+    this.localStorageRepository.mkdir(dirPath);
+    const finalPath = `${dirPath}/latest.json`;
+    const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    this.localStorageRepository.write(tmpPath, JSON.stringify(value));
+    this.localStorageRepository.rename(tmpPath, finalPath);
+  };
 }

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

@@ -5,7 +5,7 @@ import {
   DiskBlocks,
   ProcHostMetricsRepository,
   cpuUsedPercentFromSamples,
-  cycleMinutesFromMtimes,
+  cycleMinutesFromFetchTimestamps,
   parseCpuSample,
   parseDiskUsedPercent,
   parseLoadAverages,
@@ -88,18 +88,39 @@ describe('parseDiskUsedPercent', () => {
   });
 });
 
-describe('cycleMinutesFromMtimes', () => {
-  it('rounds the gap between the two newest generations to whole minutes', () => {
-    expect(cycleMinutesFromMtimes([1782469254.0, 1782468443.0])).toBe(14);
+describe('cycleMinutesFromFetchTimestamps', () => {
+  it('rounds the gap between the previous and current fetch to whole minutes', () => {
+    expect(
+      cycleMinutesFromFetchTimestamps(
+        '2026-07-07T00:00:00.000Z',
+        '2026-07-07T00:14:00.000Z',
+      ),
+    ).toBe(14);
   });
 
   it('rounds a 1620 second gap to 27 minutes', () => {
-    expect(cycleMinutesFromMtimes([1620.0, 0.0])).toBe(27);
+    expect(
+      cycleMinutesFromFetchTimestamps(
+        '2026-07-07T00:00:00.000Z',
+        '2026-07-07T00:27:00.000Z',
+      ),
+    ).toBe(27);
   });
 
-  it('returns null when a second generation is missing', () => {
-    expect(cycleMinutesFromMtimes([1000.0])).toBeNull();
-    expect(cycleMinutesFromMtimes([])).toBeNull();
+  it('returns null when either timestamp is missing', () => {
+    expect(
+      cycleMinutesFromFetchTimestamps(null, '2026-07-07T00:00:00.000Z'),
+    ).toBeNull();
+    expect(
+      cycleMinutesFromFetchTimestamps('2026-07-07T00:00:00.000Z', null),
+    ).toBeNull();
+    expect(cycleMinutesFromFetchTimestamps(null, null)).toBeNull();
+  });
+
+  it('returns null when a timestamp is not parseable', () => {
+    expect(
+      cycleMinutesFromFetchTimestamps('not-a-date', '2026-07-07T00:00:00.000Z'),
+    ).toBeNull();
   });
 });
 

package/src/adapter/repositories/ProcHostMetricsRepository.ts

@@ -111,15 +111,19 @@ export const parseLoadAverages = (loadavgText: string): LoadAverages => {
   return { oneMinute, fiveMinute, fifteenMinute };
 };
 
-export const cycleMinutesFromMtimes = (
-  mtimesDescendingSeconds: number[],
+export const cycleMinutesFromFetchTimestamps = (
+  previousFetchedAtIso: string | null,
+  currentFetchedAtIso: string | null,
 ): number | null => {
-  if (mtimesDescendingSeconds.length < 2) {
+  if (previousFetchedAtIso === null || currentFetchedAtIso === null) {
     return null;
   }
-  return Math.round(
-    (mtimesDescendingSeconds[0] - mtimesDescendingSeconds[1]) / 60,
-  );
+  const previousMs = new Date(previousFetchedAtIso).getTime();
+  const currentMs = new Date(currentFetchedAtIso).getTime();
+  if (!Number.isFinite(previousMs) || !Number.isFinite(currentMs)) {
+    return null;
+  }
+  return Math.round((currentMs - previousMs) / 60000);
 };
 
 export class ProcHostMetricsRepository {