github-issue-tower-defence-management 1.179.0 → 1.180.0

package/src/adapter/entry-points/console/ui-dist/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-KCmqh781.js"></script>
+    <script type="module" crossorigin src="/assets/index-I_2Yu8fM.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DeZcPNCr.css">
   </head>
   <body>

package/src/adapter/entry-points/console/webServer.ts

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { IssueAttachmentRepository } from '../../../domain/usecases/adapter-interfaces/IssueAttachmentRepository';
 import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { ProjectRepository } from '../../../domain/usecases/adapter-interfaces/ProjectRepository';
 import {
   CONSOLE_LIST_TAB_NAMES,
   buildConsoleDataResponse,
@@ -28,6 +29,7 @@ import {
   handleComment,
   handleCreateIssue,
   handleIntmux,
+  handleReorderStory,
   handleReview,
   handleReviewComment,
   handleTriage,
@@ -232,6 +234,7 @@ export type WebServerOptions = {
   resolveProject?: ConsoleProjectResolver | null;
   isPjcodeConfigured?: ConsolePjcodeValidator | null;
   issueAttachmentRepository?: IssueAttachmentRepository | null;
+  projectRepository?: Pick<ProjectRepository, 'updateStoryList'> | null;
   issueTitleStateCache?: IssueTitleStateCache | null;
   pullRequestStatusCache?: PullRequestStatusCache | null;
 };
@@ -529,6 +532,8 @@ const dispatchOperation = (
       return handleAttachmentUpload(context, body);
     case '/api/createissue':
       return handleCreateIssue(context, body);
+    case '/api/reorderstory':
+      return handleReorderStory(context, body);
     default:
       return null;
   }
@@ -551,12 +556,18 @@ const handleOperationApi = async (
   }
   const resolveIssueRepository =
     options.resolveIssueRepository ?? ((): IssueRepository => issueRepository);
+  const projectRepository = options.projectRepository ?? null;
   const context: ConsoleOperationContext = {
     resolveIssueRepository,
     resolveProject,
     isPjcodeConfigured,
     consoleDataOutputDir: options.consoleDataOutputDir,
     issueAttachmentRepository: options.issueAttachmentRepository ?? null,
+    updateStoryList:
+      projectRepository !== null
+        ? (project, stories) =>
+            projectRepository.updateStoryList(project, stories)
+        : null,
   };
   const dispatched = dispatchOperation(context, requestPath, body);
   if (dispatched === null) {

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

@@ -0,0 +1,60 @@
+import { SystemDateRepository } from './SystemDateRepository';
+
+describe('SystemDateRepository', () => {
+  const repo = new SystemDateRepository();
+
+  const jan15At09h05 = new Date(Date.UTC(2026, 0, 15, 9, 5, 0));
+  const jan15At10h30 = new Date(Date.UTC(2026, 0, 15, 10, 30, 0));
+  const jan16At08h00 = new Date(Date.UTC(2026, 0, 16, 8, 0, 0));
+
+  describe('formatDurationToHHMM', () => {
+    it('formats whole hours', () => {
+      expect(repo.formatDurationToHHMM(120)).toBe('02:00');
+    });
+
+    it('formats hours and minutes', () => {
+      expect(repo.formatDurationToHHMM(90)).toBe('01:30');
+    });
+
+    it('formats minutes only', () => {
+      expect(repo.formatDurationToHHMM(5)).toBe('00:05');
+    });
+  });
+
+  describe('formatDateWithDayOfWeek', () => {
+    it('formats a UTC date with day-of-week in YYYY/MM/DD (Day) form', () => {
+      expect(repo.formatDateWithDayOfWeek(jan15At09h05)).toBe(
+        '2026/01/15 (Thu)',
+      );
+    });
+  });
+
+  describe('formatDateTimeWithDayOfWeek', () => {
+    it('appends UTC HH:MM to the date-with-day-of-week', () => {
+      expect(repo.formatDateTimeWithDayOfWeek(jan15At09h05)).toBe(
+        '2026/01/15 (Thu) 09:05',
+      );
+    });
+
+    it('pads single-digit hour and minute', () => {
+      const date = new Date(Date.UTC(2026, 2, 3, 4, 7, 0));
+      expect(repo.formatDateTimeWithDayOfWeek(date)).toBe(
+        '2026/03/03 (Tue) 04:07',
+      );
+    });
+  });
+
+  describe('formatStartEnd', () => {
+    it('omits the date for same-day end', () => {
+      expect(repo.formatStartEnd(jan15At09h05, jan15At10h30)).toBe(
+        '2026/01/15 (Thu) 09:05 - 10:30',
+      );
+    });
+
+    it('includes full date-time for end on a different day', () => {
+      expect(repo.formatStartEnd(jan15At09h05, jan16At08h00)).toBe(
+        '2026/01/15 (Thu) 09:05 - 2026/01/16 (Fri) 08:00',
+      );
+    });
+  });
+});

package/src/adapter/repositories/SystemDateRepository.ts

@@ -9,25 +9,25 @@ export class SystemDateRepository implements DateRepository {
   };
   formatDateTimeWithDayOfWeek = (date: Date): string => {
     const dateWithDayOfWeek = this.formatDateWithDayOfWeek(date);
-    const hours = String(date.getHours()).padStart(2, '0');
-    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
     return `${dateWithDayOfWeek} ${hours}:${minutes}`;
   };
 
   formatDateWithDayOfWeek = (date: Date): string => {
     const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][
-      date.getDay()
+      date.getUTCDay()
     ];
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    return `${date.getFullYear()}/${month}/${day} (${dayOfWeek})`;
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return `${date.getUTCFullYear()}/${month}/${day} (${dayOfWeek})`;
   };
   formatStartEnd = (start: Date, end: Date): string => {
     const endDate =
-      start.getFullYear() === end.getFullYear() &&
-      start.getMonth() === end.getMonth() &&
-      start.getDate() === end.getDate()
-        ? `${String(end.getHours()).padStart(2, '0')}:${String(end.getMinutes()).padStart(2, '0')}`
+      start.getUTCFullYear() === end.getUTCFullYear() &&
+      start.getUTCMonth() === end.getUTCMonth() &&
+      start.getUTCDate() === end.getUTCDate()
+        ? `${String(end.getUTCHours()).padStart(2, '0')}:${String(end.getUTCMinutes()).padStart(2, '0')}`
         : this.formatDateTimeWithDayOfWeek(end);
     return `${this.formatDateTimeWithDayOfWeek(start)} - ${endDate}`;
   };

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -394,6 +394,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       const cachedProject = buildTestProject('cached-project');
+      const freshProject = buildTestProject('cached-project');
       dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
       localStorageCacheRepository.getSingle.mockResolvedValue({
         lastFetchedAt: '2026-07-07T00:30:00.000Z',
@@ -406,6 +407,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           ),
         ],
       });
+      projectRepository.getProject.mockResolvedValue(freshProject);
       graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
         buildLightItem(
           'item-fresh',
@@ -427,8 +429,10 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       const result = await repository.getAllIssues('cached-project');
 
       expect(result.cacheUsed).toBe(true);
-      expect(result.project).toBe(cachedProject);
-      expect(projectRepository.getProject).not.toHaveBeenCalled();
+      expect(result.project).toBe(freshProject);
+      expect(projectRepository.getProject).toHaveBeenCalledWith(
+        'cached-project',
+      );
       const lightCall =
         graphqlProjectItemRepository.fetchProjectItemsLight.mock.calls[0];
       expect(lightCall[0]).toBe('cached-project');
@@ -463,6 +467,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
@@ -472,6 +477,9 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         project: buildTestProject('cached-project'),
         issues: [],
       });
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('cached-project'),
+      );
       graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
         buildLightItem(
           'wellBefore',
@@ -509,6 +517,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:30:00Z'));
@@ -518,6 +527,9 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         project: buildTestProject('cached-project'),
         issues: [],
       });
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('cached-project'),
+      );
       graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
         buildLightItem(
           'previousDay',
@@ -548,6 +560,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
@@ -562,6 +575,9 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           ),
         ],
       });
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('cached-project'),
+      );
       graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
         buildLightItem(
           'stale',
@@ -618,6 +634,252 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('getAllIssues story option rename detection', () => {
+    const buildStoryOption = (
+      id: string,
+      name: string,
+    ): {
+      id: string;
+      name: string;
+      color: 'GRAY';
+      description: string;
+    } => ({ id, name, color: 'GRAY', description: '' });
+
+    const buildProjectWithStories = (
+      id: string,
+      stories: { id: string; name: string }[],
+    ): Project => ({
+      ...buildTestProject(id),
+      story: {
+        name: 'Story',
+        fieldId: 'story-field-id',
+        databaseId: 1,
+        stories: stories.map((s) => buildStoryOption(s.id, s.name)),
+        workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
+      },
+    });
+
+    it('calls projectRepository.getProject on every incremental fetch cycle', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildTestProject('cached-project');
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockResolvedValue(cachedProject);
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      await repository.getAllIssues('cached-project');
+
+      expect(projectRepository.getProject).toHaveBeenCalledWith(
+        'cached-project',
+      );
+    });
+
+    it('escalates to full fetch when a story option name changes between cache and fresh project', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Old Story Name' },
+      ]);
+      const freshProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'New Story Name' },
+      ]);
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockResolvedValue(freshProject);
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).toHaveBeenCalledWith('cached-project');
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemsLight,
+      ).not.toHaveBeenCalled();
+      expect(result.cacheUsed).toBe(false);
+    });
+
+    it('escalates to full fetch when a story option is removed in the fresh project', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+        { id: 'opt-2', name: 'Story B' },
+      ]);
+      const freshProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+      ]);
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockResolvedValue(freshProject);
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).toHaveBeenCalledWith('cached-project');
+      expect(result.cacheUsed).toBe(false);
+    });
+
+    it('proceeds with incremental fetch when story options are unchanged', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+      ]);
+      const freshProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+      ]);
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockResolvedValue(freshProject);
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).not.toHaveBeenCalled();
+      expect(result.cacheUsed).toBe(true);
+    });
+
+    it('writes the fresh project (not cache.project) to cache during incremental fetch', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+      ]);
+      const freshProject = buildProjectWithStories('cached-project', [
+        { id: 'opt-1', name: 'Story A' },
+        { id: 'opt-2', name: 'Story B (new)' },
+      ]);
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockResolvedValue(freshProject);
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      await repository.getAllIssues('cached-project');
+
+      const cacheWrite = localStorageCacheRepository.setSingle.mock.calls[0][1];
+      expect(cacheWrite).toEqual(
+        expect.objectContaining({ project: freshProject }),
+      );
+    });
+
+    it('falls back to cache.project and logs a warning when getProject fails during incremental fetch', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildTestProject('cached-project');
+      const warnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+      projectRepository.getProject.mockRejectedValue(
+        new Error('network error'),
+      );
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(result.cacheUsed).toBe(true);
+      expect(result.project).toBe(cachedProject);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to refresh project metadata'),
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('cached-project'),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('re-throws the error when getProject fails during a full fetch with no cache', async () => {
+      const {
+        repository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+      projectRepository.getProject.mockRejectedValue(
+        new Error('project fetch failed'),
+      );
+
+      await expect(repository.getAllIssues('cached-project')).rejects.toThrow(
+        'project fetch failed',
+      );
+    });
+  });
+
   describe('getLastIssuesFetchedAt', () => {
     it('reports null before any fetch has happened for the project', () => {
       const { repository } = createApiV3CheerioRestIssueRepository();
@@ -653,6 +915,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
@@ -662,6 +925,9 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         project: buildTestProject('cached-project'),
         issues: [],
       });
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('cached-project'),
+      );
       graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([]);
       localStorageCacheRepository.setSingle.mockResolvedValue();
 

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -808,11 +808,41 @@ export class ApiV3CheerioRestIssueRepository
       now.getTime() - new Date(cache.lastFullFetchAt).getTime() >=
         FULL_ISSUE_FETCH_INTERVAL_MS;
 
-    if (isFullFetch) {
-      const project = await this.projectRepository.getProject(projectId);
-      if (!project) {
+    let project: Project;
+    try {
+      const freshProject = await this.projectRepository.getProject(projectId);
+      if (!freshProject) {
         throw new Error(`Project not found. projectId: ${projectId}`);
       }
+      project = freshProject;
+    } catch (error) {
+      if (!isFullFetch && cache !== null) {
+        console.warn(
+          `Failed to refresh project metadata, using cached. projectId: ${projectId}, error: ${String(error)}`,
+        );
+        project = cache.project;
+      } else {
+        throw error;
+      }
+    }
+
+    const cacheStoriesByOptionId = new Map(
+      cache?.project.story?.stories.map((s) => [s.id, s.name]) ?? [],
+    );
+    const freshStoryOptionIds = new Set(
+      project.story?.stories.map((s) => s.id) ?? [],
+    );
+    const storyOptionsChanged =
+      cache !== null &&
+      ([...cacheStoriesByOptionId.entries()].some(
+        ([id, name]) =>
+          !freshStoryOptionIds.has(id) ||
+          project.story?.stories.find((s) => s.id === id)?.name !== name,
+      ) ??
+        false);
+    const effectiveIsFullFetch = isFullFetch || storyOptionsChanged;
+
+    if (effectiveIsFullFetch) {
       const items =
         await this.graphqlProjectItemRepository.fetchProjectItems(projectId);
       const issues = items.map((item) => this.convertProjectItemToIssue(item));
@@ -827,7 +857,6 @@ export class ApiV3CheerioRestIssueRepository
       return { issues, project, cacheUsed: false };
     }
 
-    const project = cache.project;
     const lastFetchedAt = new Date(cache.lastFetchedAt);
     const cutoff = new Date(
       lastFetchedAt.getTime() - INCREMENTAL_FETCH_SKEW_BUFFER_MS,

package/src/domain/usecases/AnalyzeProblemByIssueUseCase.ts

@@ -26,7 +26,7 @@ export class AnalyzeProblemByIssueUseCase {
       !story ||
       !input.targetDates.find(
         (targetDate) =>
-          targetDate.getHours() === 0 && targetDate.getMinutes() === 0,
+          targetDate.getUTCHours() === 0 && targetDate.getUTCMinutes() === 0,
       )
     ) {
       return;

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

@@ -0,0 +1,80 @@
+import { mock } from 'jest-mock-extended';
+import { AnalyzeStoriesUseCase } from './AnalyzeStoriesUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { DateRepository } from './adapter-interfaces/DateRepository';
+import { Project } from '../entities/Project';
+import { StoryObject } from '../entities/StoryObjectMap';
+
+describe('AnalyzeStoriesUseCase', () => {
+  const mockIssueRepository = mock<IssueRepository>();
+  const mockDateRepository = mock<DateRepository>();
+
+  let useCase: AnalyzeStoriesUseCase;
+
+  const projectWithStory: Project = {
+    ...mock<Project>(),
+    story: {
+      name: 'Story',
+      fieldId: 'story-field',
+      databaseId: 1,
+      stories: [],
+      workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
+    },
+  };
+
+  const commonInput = {
+    project: projectWithStory,
+    issues: [],
+    cacheUsed: false,
+    manager: 'manager-user',
+    org: 'org',
+    repo: 'repo',
+    urlOfStoryView: 'https://github.com/org/repo',
+    storyObjectMap: new Map<string, StoryObject>(),
+    members: [],
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useCase = new AnalyzeStoriesUseCase(
+      mockIssueRepository,
+      mockDateRepository,
+    );
+  });
+
+  describe('run — UTC 05:00 guard', () => {
+    it('returns early when no targetDate is at UTC 05:00', async () => {
+      const nonMatchingDate = new Date(Date.UTC(2026, 0, 15, 4, 0, 0));
+
+      await useCase.run({ ...commonInput, targetDates: [nonMatchingDate] });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('proceeds when a targetDate is exactly UTC 05:00', async () => {
+      const matchingDate = new Date(Date.UTC(2026, 0, 15, 5, 0, 0));
+
+      await useCase.run({ ...commonInput, targetDates: [matchingDate] });
+
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns early when project has no story field', async () => {
+      const projectWithoutStory: Project = { ...projectWithStory, story: null };
+
+      await useCase.run({
+        ...commonInput,
+        project: projectWithoutStory,
+        targetDates: [new Date(Date.UTC(2026, 0, 15, 5, 0, 0))],
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('returns early when targetDates is empty', async () => {
+      await useCase.run({ ...commonInput, targetDates: [] });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/domain/usecases/AnalyzeStoriesUseCase.ts

@@ -30,7 +30,7 @@ export class AnalyzeStoriesUseCase {
       !story ||
       !input.targetDates.find(
         (targetDate) =>
-          targetDate.getHours() === 5 && targetDate.getMinutes() === 0,
+          targetDate.getUTCHours() === 5 && targetDate.getUTCMinutes() === 0,
       )
     ) {
       return;

package/src/domain/usecases/ClearPastNextActionDateHourUseCase.ts

@@ -28,10 +28,12 @@ export class ClearPastNextActionDateHourUseCase {
         }
         const scheduledDate = issue.nextActionDate ?? now;
         const scheduledTime = new Date(
-          scheduledDate.getFullYear(),
-          scheduledDate.getMonth(),
-          scheduledDate.getDate(),
-          issue.nextActionHour,
+          Date.UTC(
+            scheduledDate.getUTCFullYear(),
+            scheduledDate.getUTCMonth(),
+            scheduledDate.getUTCDate(),
+            issue.nextActionHour,
+          ),
         );
         if (scheduledTime.getTime() > now.getTime()) {
           continue;