github-issue-tower-defence-management 1.58.3 → 1.60.0

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

@@ -0,0 +1,313 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import {
+  SqliteClaudeMessageResponseRepository,
+  generateUlid,
+} from './SqliteClaudeMessageResponseRepository';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const requireRecord = (value: unknown): Record<string, unknown> => {
+  if (!isRecord(value))
+    throw new Error(`Expected record, got: ${String(value)}`);
+  return value;
+};
+
+const requireRecordArray = (value: unknown[]): Array<Record<string, unknown>> =>
+  value.map(requireRecord);
+
+const buildTestResponse = (
+  overrides: Partial<ClaudeMessageResponse> = {},
+): ClaudeMessageResponse => ({
+  id: generateUlid(),
+  observedAt: new Date('2024-01-15T10:30:00.000Z'),
+  tokenName: 'hashed-token-abc',
+  externalClaudeMessageId: 'msg_01XFDUDYJgAACTvykiHMn8xy',
+  externalClaudeRequestId: 'req_01234',
+  httpStatus: 200,
+  model: 'claude-sonnet-4-5',
+  role: 'assistant',
+  stopReason: 'end_turn',
+  stopSequence: null,
+  inputTokens: 100,
+  outputTokens: 50,
+  cacheCreationInputTokens: null,
+  cacheReadInputTokens: null,
+  ephemeral5mInputTokens: null,
+  ephemeral1hInputTokens: null,
+  serviceTier: 'standard',
+  inferenceGeo: null,
+  errorType: null,
+  errorMessage: null,
+  anthropicRatelimitUnifiedStatus: 'active',
+  anthropicRatelimitUnified5hStatus: 'active',
+  anthropicRatelimitUnified5hUtilization: 42.5,
+  anthropicRatelimitUnified5hReset: 1705316200,
+  anthropicRatelimitUnified7dStatus: 'active',
+  anthropicRatelimitUnified7dUtilization: 10.0,
+  anthropicRatelimitUnified7dReset: 1705920000,
+  retryAfter: null,
+  anthropicOrganizationId: 'org-abc123',
+  ...overrides,
+});
+
+describe('generateUlid', () => {
+  it('generates a 26-character uppercase alphanumeric string', () => {
+    const ulid = generateUlid();
+    expect(ulid).toHaveLength(26);
+    expect(/^[0-9A-HJKMNP-TV-Z]{26}$/.test(ulid)).toBe(true);
+  });
+
+  it('generates unique values across multiple calls', () => {
+    const ids = new Set(Array.from({ length: 100 }, () => generateUlid()));
+    expect(ids.size).toBe(100);
+  });
+
+  it('generates a value whose first 10 characters encode a timestamp no later than the current time', () => {
+    const before = Date.now();
+    const ulid = generateUlid();
+    const after = Date.now();
+    const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+    const timeChars = ulid.slice(0, 10);
+    let decoded = 0;
+    for (const char of timeChars) {
+      decoded = decoded * 32 + ENCODING.indexOf(char);
+    }
+    expect(decoded).toBeGreaterThanOrEqual(before);
+    expect(decoded).toBeLessThanOrEqual(after);
+  });
+});
+
+describe('SqliteClaudeMessageResponseRepository', () => {
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-msg-repo-test-'));
+    dbPath = path.join(tmpDir, 'claude_message_response.db');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('constructor', () => {
+    it('creates the database file when it does not exist', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      expect(fs.existsSync(dbPath)).toBe(true);
+    });
+
+    it('creates the parent directory when it does not exist', () => {
+      const nestedDbPath = path.join(tmpDir, 'nested', 'dir', 'test.db');
+      new SqliteClaudeMessageResponseRepository(nestedDbPath);
+      expect(fs.existsSync(nestedDbPath)).toBe(true);
+    });
+
+    it('creates the claude_message_response table on first open', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      const db = new Database(dbPath);
+      const row = db
+        .prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='claude_message_response'",
+        )
+        .get();
+      db.close();
+      expect(row).toBeDefined();
+    });
+
+    it('does not fail when reopened against an existing database', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      expect(() => {
+        new SqliteClaudeMessageResponseRepository(dbPath);
+      }).not.toThrow();
+    });
+  });
+
+  describe('append', () => {
+    it('inserts a row with all fields set', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse();
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['id']).toBe(response.id);
+      expect(row['observed_at']).toBe(response.observedAt.getTime());
+      expect(row['token_name']).toBe(response.tokenName);
+      expect(row['external_claude_message_id']).toBe(
+        response.externalClaudeMessageId,
+      );
+      expect(row['external_claude_request_id']).toBe(
+        response.externalClaudeRequestId,
+      );
+      expect(row['http_status']).toBe(response.httpStatus);
+      expect(row['model']).toBe(response.model);
+      expect(row['role']).toBe(response.role);
+      expect(row['stop_reason']).toBe(response.stopReason);
+      expect(row['stop_sequence']).toBeNull();
+      expect(row['input_tokens']).toBe(response.inputTokens);
+      expect(row['output_tokens']).toBe(response.outputTokens);
+      expect(row['cache_creation_input_tokens']).toBeNull();
+      expect(row['cache_read_input_tokens']).toBeNull();
+      expect(row['ephemeral_5m_input_tokens']).toBeNull();
+      expect(row['ephemeral_1h_input_tokens']).toBeNull();
+      expect(row['service_tier']).toBe(response.serviceTier);
+      expect(row['inference_geo']).toBeNull();
+      expect(row['error_type']).toBeNull();
+      expect(row['error_message']).toBeNull();
+      expect(row['anthropic_ratelimit_unified_status']).toBe(
+        response.anthropicRatelimitUnifiedStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_status']).toBe(
+        response.anthropicRatelimitUnified5hStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_utilization']).toBe(
+        response.anthropicRatelimitUnified5hUtilization,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_reset']).toBe(
+        response.anthropicRatelimitUnified5hReset,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_status']).toBe(
+        response.anthropicRatelimitUnified7dStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_utilization']).toBe(
+        response.anthropicRatelimitUnified7dUtilization,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_reset']).toBe(
+        response.anthropicRatelimitUnified7dReset,
+      );
+      expect(row['retry_after']).toBeNull();
+      expect(row['anthropic_organization_id']).toBe(
+        response.anthropicOrganizationId,
+      );
+    });
+
+    it('inserts a row where all nullable fields are null', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse({
+        externalClaudeMessageId: null,
+        externalClaudeRequestId: null,
+        model: null,
+        role: null,
+        stopReason: null,
+        stopSequence: null,
+        inputTokens: null,
+        outputTokens: null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: null,
+        ephemeral5mInputTokens: null,
+        ephemeral1hInputTokens: null,
+        serviceTier: null,
+        inferenceGeo: null,
+        errorType: null,
+        errorMessage: null,
+        anthropicRatelimitUnifiedStatus: null,
+        anthropicRatelimitUnified5hStatus: null,
+        anthropicRatelimitUnified5hUtilization: null,
+        anthropicRatelimitUnified5hReset: null,
+        anthropicRatelimitUnified7dStatus: null,
+        anthropicRatelimitUnified7dUtilization: null,
+        anthropicRatelimitUnified7dReset: null,
+        retryAfter: null,
+        anthropicOrganizationId: null,
+      });
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['id']).toBe(response.id);
+      expect(row['http_status']).toBe(response.httpStatus);
+      expect(row['external_claude_message_id']).toBeNull();
+      expect(row['model']).toBeNull();
+    });
+
+    it('inserts an error response with error fields set', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse({
+        httpStatus: 429,
+        model: null,
+        role: null,
+        stopReason: null,
+        inputTokens: null,
+        outputTokens: null,
+        errorType: 'rate_limit_error',
+        errorMessage: 'Too many requests',
+        retryAfter: 30,
+      });
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['http_status']).toBe(429);
+      expect(row['error_type']).toBe('rate_limit_error');
+      expect(row['error_message']).toBe('Too many requests');
+      expect(row['retry_after']).toBe(30);
+    });
+
+    it('inserts multiple rows appending each independently', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const responses = [
+        buildTestResponse({ httpStatus: 200 }),
+        buildTestResponse({ httpStatus: 429 }),
+        buildTestResponse({ httpStatus: 200 }),
+      ];
+
+      for (const response of responses) {
+        repo.append(response);
+      }
+
+      const db = new Database(dbPath);
+      const rows = requireRecordArray(
+        db.prepare('SELECT id FROM claude_message_response').all(),
+      );
+      db.close();
+
+      expect(rows).toHaveLength(3);
+      const rowIds = rows.map((r) => r['id']).sort();
+      const responseIds = responses.map((r) => r.id).sort();
+      expect(rowIds).toEqual(responseIds);
+    });
+
+    it('persists rows that survive a repository close and reopen', () => {
+      const firstRepo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse();
+      firstRepo.append(response);
+
+      const secondRepo = new SqliteClaudeMessageResponseRepository(dbPath);
+
+      const db = new Database(dbPath);
+      const countRow = requireRecord(
+        db.prepare('SELECT COUNT(*) as cnt FROM claude_message_response').get(),
+      );
+      db.close();
+
+      expect(countRow['cnt']).toBe(1);
+      expect(secondRepo).toBeDefined();
+    });
+  });
+});

package/src/adapter/repositories/SqliteClaudeMessageResponseRepository.ts

@@ -0,0 +1,164 @@
+import * as crypto from 'crypto';
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
+
+const ULID_ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+const encodeUlidTime = (ms: number): string => {
+  let str = '';
+  for (let i = 9; i >= 0; i--) {
+    str = ULID_ENCODING[ms % 32] + str;
+    ms = Math.floor(ms / 32);
+  }
+  return str;
+};
+
+const encodeUlidRandom = (): string => {
+  const bytes = crypto.randomBytes(10);
+  let bits = 0;
+  let bitLen = 0;
+  let str = '';
+  for (let i = 0; i < bytes.length && str.length < 16; i++) {
+    bits = (bits << 8) | bytes[i];
+    bitLen += 8;
+    while (bitLen >= 5 && str.length < 16) {
+      str += ULID_ENCODING[(bits >>> (bitLen - 5)) & 0x1f];
+      bitLen -= 5;
+    }
+  }
+  return str;
+};
+
+export const generateUlid = (): string =>
+  encodeUlidTime(Date.now()) + encodeUlidRandom();
+
+const CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS claude_message_response (
+    id TEXT PRIMARY KEY,
+    observed_at INTEGER NOT NULL,
+    token_name TEXT NOT NULL,
+    external_claude_message_id TEXT,
+    external_claude_request_id TEXT,
+    http_status INTEGER NOT NULL,
+    model TEXT,
+    role TEXT,
+    stop_reason TEXT,
+    stop_sequence TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    cache_creation_input_tokens INTEGER,
+    cache_read_input_tokens INTEGER,
+    ephemeral_5m_input_tokens INTEGER,
+    ephemeral_1h_input_tokens INTEGER,
+    service_tier TEXT,
+    inference_geo TEXT,
+    error_type TEXT,
+    error_message TEXT,
+    anthropic_ratelimit_unified_status TEXT,
+    anthropic_ratelimit_unified_5h_status TEXT,
+    anthropic_ratelimit_unified_5h_utilization REAL,
+    anthropic_ratelimit_unified_5h_reset REAL,
+    anthropic_ratelimit_unified_7d_status TEXT,
+    anthropic_ratelimit_unified_7d_utilization REAL,
+    anthropic_ratelimit_unified_7d_reset REAL,
+    retry_after REAL,
+    anthropic_organization_id TEXT
+  ) STRICT
+`;
+
+const INSERT_SQL = `
+  INSERT INTO claude_message_response (
+    id, observed_at, token_name,
+    external_claude_message_id, external_claude_request_id,
+    http_status, model, role, stop_reason, stop_sequence,
+    input_tokens, output_tokens,
+    cache_creation_input_tokens, cache_read_input_tokens,
+    ephemeral_5m_input_tokens, ephemeral_1h_input_tokens,
+    service_tier, inference_geo,
+    error_type, error_message,
+    anthropic_ratelimit_unified_status,
+    anthropic_ratelimit_unified_5h_status,
+    anthropic_ratelimit_unified_5h_utilization,
+    anthropic_ratelimit_unified_5h_reset,
+    anthropic_ratelimit_unified_7d_status,
+    anthropic_ratelimit_unified_7d_utilization,
+    anthropic_ratelimit_unified_7d_reset,
+    retry_after, anthropic_organization_id
+  ) VALUES (
+    @id, @observedAt, @tokenName,
+    @externalClaudeMessageId, @externalClaudeRequestId,
+    @httpStatus, @model, @role, @stopReason, @stopSequence,
+    @inputTokens, @outputTokens,
+    @cacheCreationInputTokens, @cacheReadInputTokens,
+    @ephemeral5mInputTokens, @ephemeral1hInputTokens,
+    @serviceTier, @inferenceGeo,
+    @errorType, @errorMessage,
+    @anthropicRatelimitUnifiedStatus,
+    @anthropicRatelimitUnified5hStatus,
+    @anthropicRatelimitUnified5hUtilization,
+    @anthropicRatelimitUnified5hReset,
+    @anthropicRatelimitUnified7dStatus,
+    @anthropicRatelimitUnified7dUtilization,
+    @anthropicRatelimitUnified7dReset,
+    @retryAfter, @anthropicOrganizationId
+  )
+`;
+
+export class SqliteClaudeMessageResponseRepository implements ClaudeMessageResponseRepository {
+  private readonly db: Database.Database;
+  private readonly insert: Database.Statement;
+
+  constructor(dbPath: string) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.exec(CREATE_TABLE_SQL);
+    this.insert = this.db.prepare(INSERT_SQL);
+  }
+
+  append = (response: ClaudeMessageResponse): void => {
+    this.insert.run({
+      id: response.id,
+      observedAt: response.observedAt.getTime(),
+      tokenName: response.tokenName,
+      externalClaudeMessageId: response.externalClaudeMessageId,
+      externalClaudeRequestId: response.externalClaudeRequestId,
+      httpStatus: response.httpStatus,
+      model: response.model,
+      role: response.role,
+      stopReason: response.stopReason,
+      stopSequence: response.stopSequence,
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens,
+      cacheCreationInputTokens: response.cacheCreationInputTokens,
+      cacheReadInputTokens: response.cacheReadInputTokens,
+      ephemeral5mInputTokens: response.ephemeral5mInputTokens,
+      ephemeral1hInputTokens: response.ephemeral1hInputTokens,
+      serviceTier: response.serviceTier,
+      inferenceGeo: response.inferenceGeo,
+      errorType: response.errorType,
+      errorMessage: response.errorMessage,
+      anthropicRatelimitUnifiedStatus: response.anthropicRatelimitUnifiedStatus,
+      anthropicRatelimitUnified5hStatus:
+        response.anthropicRatelimitUnified5hStatus,
+      anthropicRatelimitUnified5hUtilization:
+        response.anthropicRatelimitUnified5hUtilization,
+      anthropicRatelimitUnified5hReset:
+        response.anthropicRatelimitUnified5hReset,
+      anthropicRatelimitUnified7dStatus:
+        response.anthropicRatelimitUnified7dStatus,
+      anthropicRatelimitUnified7dUtilization:
+        response.anthropicRatelimitUnified7dUtilization,
+      anthropicRatelimitUnified7dReset:
+        response.anthropicRatelimitUnified7dReset,
+      retryAfter: response.retryAfter,
+      anthropicOrganizationId: response.anthropicOrganizationId,
+    });
+  };
+}

package/src/domain/entities/ClaudeMessageResponse.ts

@@ -0,0 +1,31 @@
+export type ClaudeMessageResponse = {
+  id: string;
+  observedAt: Date;
+  tokenName: string;
+  externalClaudeMessageId: string | null;
+  externalClaudeRequestId: string | null;
+  httpStatus: number;
+  model: string | null;
+  role: string | null;
+  stopReason: string | null;
+  stopSequence: string | null;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheCreationInputTokens: number | null;
+  cacheReadInputTokens: number | null;
+  ephemeral5mInputTokens: number | null;
+  ephemeral1hInputTokens: number | null;
+  serviceTier: string | null;
+  inferenceGeo: string | null;
+  errorType: string | null;
+  errorMessage: string | null;
+  anthropicRatelimitUnifiedStatus: string | null;
+  anthropicRatelimitUnified5hStatus: string | null;
+  anthropicRatelimitUnified5hUtilization: number | null;
+  anthropicRatelimitUnified5hReset: number | null;
+  anthropicRatelimitUnified7dStatus: string | null;
+  anthropicRatelimitUnified7dUtilization: number | null;
+  anthropicRatelimitUnified7dReset: number | null;
+  retryAfter: number | null;
+  anthropicOrganizationId: string | null;
+};

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

@@ -23,6 +23,7 @@ import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
+import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -112,6 +113,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<RevertOrphanedPreparationUseCase>();
     const mockRevertNotReadyAwaitingQualityCheckUseCase =
       mock<RevertNotReadyAwaitingQualityCheckUseCase>();
+    const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -135,6 +137,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
       mockRevertNotReadyAwaitingQualityCheckUseCase,
+      mockUpdateRateLimitCacheUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,
@@ -367,6 +370,66 @@ describe('HandleScheduledEventUseCase', () => {
       ).not.toHaveBeenCalled();
     });
 
+    it('should invoke UpdateRateLimitCacheUseCase before StartPreparationUseCase when startPreparation is configured', async () => {
+      const callOrder: string[] = [];
+      mockUpdateRateLimitCacheUseCase.run.mockImplementation(async () => {
+        callOrder.push('updateRateLimitCache');
+      });
+      mockStartPreparationUseCase.run.mockImplementation(async () => {
+        callOrder.push('startPreparation');
+      });
+
+      const input = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+        allowIssueCacheMinutes: 60,
+        startPreparation: {
+          defaultAgentName: 'aw',
+          configFilePath: '/path/to/config.yml',
+          maximumPreparingIssuesCount: null,
+        },
+      };
+
+      mockProjectRepository.getProject.mockResolvedValue(mock<Project>());
+      await useCase.run(input);
+
+      expect(mockUpdateRateLimitCacheUseCase.run).toHaveBeenCalledTimes(1);
+      expect(callOrder.indexOf('updateRateLimitCache')).toBeLessThan(
+        callOrder.indexOf('startPreparation'),
+      );
+    });
+
+    it('should not invoke UpdateRateLimitCacheUseCase when startPreparation is absent', async () => {
+      const input = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+        allowIssueCacheMinutes: 60,
+      };
+
+      mockProjectRepository.getProject.mockResolvedValue(mock<Project>());
+      await useCase.run(input);
+
+      expect(mockUpdateRateLimitCacheUseCase.run).not.toHaveBeenCalled();
+    });
+
     describe('story issue creation progress logs', () => {
       const storyInput = {
         projectName: 'test-project',

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -23,6 +23,7 @@ import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
+import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -52,6 +53,7 @@ export class HandleScheduledEventUseCase {
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly revertNotReadyAwaitingQualityCheckUseCase: RevertNotReadyAwaitingQualityCheckUseCase,
+    readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -264,6 +266,11 @@ ${JSON.stringify(e)}
       });
     }
     if (input.startPreparation) {
+      if (this.updateRateLimitCacheUseCase !== null) {
+        await this.updateRateLimitCacheUseCase.run({
+          nowEpochSeconds: Date.now() / 1000,
+        });
+      }
       if (input.startPreparation.preparationProcessCheckCommand) {
         await this.revertOrphanedPreparationUseCase.run({
           projectUrl: input.projectUrl,