github-issue-tower-defence-management 1.192.0 → 1.194.0

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

@@ -1,4 +1,7 @@
-import { StartPreparationUseCase } from './StartPreparationUseCase';
+import {
+  SPAWN_CANDIDATE_BRANCH_SOURCE_CONCURRENCY,
+  StartPreparationUseCase,
+} from './StartPreparationUseCase';
 import {
   IssueRepository,
   RelatedPullRequest,
@@ -129,6 +132,7 @@ describe('StartPreparationUseCase', () => {
     };
     mockLocalCommandRunner = {
       runCommand: jest.fn(),
+      spawnInteractive: jest.fn(),
     };
     mockClaudeTokenUsageRepository = {
       ensureObservable: jest.fn().mockResolvedValue(undefined),
@@ -6888,6 +6892,112 @@ describe('StartPreparationUseCase', () => {
     expect(storyUnsetWarningCalls).toHaveLength(0);
     consoleWarnSpy.mockRestore();
   });
+
+  describe('token in-flight count refresh', () => {
+    it('refreshes the token in-flight counts once before abandoning a run so a freed slot is used', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-a',
+          token: 'token-a',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0.1,
+          blocked: false,
+          rejected: false,
+          fiveHourRejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {},
+        },
+      ]);
+      mockClaudeTokenUsageRepository.getTokenInFlightCounts
+        .mockResolvedValueOnce({ 'token-a': 6 })
+        .mockResolvedValueOnce({ 'token-a': 0 });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-opus',
+        fallbackLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: ['testuser'],
+        manager: 'manager-user',
+        codexHomeCandidates: null,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(
+        mockClaudeTokenUsageRepository.getTokenInFlightCounts.mock.calls,
+      ).toHaveLength(2);
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    });
+
+    it('abandons the run when the refreshed in-flight counts still leave no token slot', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-a',
+          token: 'token-a',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0.1,
+          blocked: false,
+          rejected: false,
+          fiveHourRejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {},
+        },
+      ]);
+      mockClaudeTokenUsageRepository.getTokenInFlightCounts.mockResolvedValue({
+        'token-a': 6,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-opus',
+        fallbackLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: ['testuser'],
+        manager: 'manager-user',
+        codexHomeCandidates: null,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    });
+  });
 });
 
 describe('StartPreparationUseCase.buildRotationOrder', () => {
@@ -6926,6 +7036,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
   };
   const mockLocalCommandRunnerForRotation: Mocked<LocalCommandRunner> = {
     runCommand: jest.fn(),
+    spawnInteractive: jest.fn(),
   };
   const mockClaudeTokenUsageRepositoryForRotation: Mocked<ClaudeTokenUsageRepository> =
     {
@@ -7232,7 +7343,7 @@ describe('StartPreparationUseCase.getTokenConcurrentLimit', () => {
         setIssueAgentField: jest.fn(),
         removeLabel: jest.fn(),
       },
-      { runCommand: jest.fn() },
+      { runCommand: jest.fn(), spawnInteractive: jest.fn() },
       {
         ensureObservable: jest.fn(),
         getAvailableTokenUsages: jest.fn(),
@@ -7283,3 +7394,103 @@ describe('StartPreparationUseCase.getTokenConcurrentLimit', () => {
     expect(useCase.getTokenConcurrentLimit(0.1, 0.1, 0.01)).toBe(1);
   });
 });
+
+describe('StartPreparationUseCase.fetchSpawnCandidateBranchSources', () => {
+  const buildRelatedPullRequest = (url: string): RelatedPullRequest => ({
+    url,
+    branchName: 'feature',
+    createdAt: new Date('2026-01-01T00:00:00Z'),
+    isDraft: false,
+    isConflicted: false,
+    mergeable: 'MERGEABLE',
+    isPassedAllCiJob: true,
+    isCiStateSuccess: true,
+    isResolvedAllReviewComments: true,
+    isBranchOutOfDate: false,
+    missingRequiredCheckNames: [],
+  });
+
+  const buildUseCase = (
+    issueRepositoryOverrides: Partial<
+      ConstructorParameters<typeof StartPreparationUseCase>[1]
+    >,
+  ): StartPreparationUseCase =>
+    new StartPreparationUseCase(
+      {
+        getByUrl: jest.fn(),
+        createField: jest.fn(),
+        updateAgentList: jest.fn(),
+      },
+      {
+        getStoryObjectMap: jest.fn(),
+        getAllOpened: jest.fn(),
+        updateStatus: jest.fn(),
+        findRelatedOpenPRs: jest.fn(),
+        getOpenPullRequest: jest.fn(),
+        closePullRequest: jest.fn(),
+        deletePullRequestBranch: jest.fn(),
+        createCommentByUrl: jest.fn(),
+        setIssueAgentField: jest.fn(),
+        removeLabel: jest.fn(),
+        ...issueRepositoryOverrides,
+      },
+      { runCommand: jest.fn(), spawnInteractive: jest.fn() },
+      {
+        ensureObservable: jest.fn(),
+        getAvailableTokenUsages: jest.fn(),
+        getTokenInFlightCounts: jest.fn(),
+        proxyBaseUrl: jest.fn(),
+      },
+      {
+        listSpawns: jest.fn().mockReturnValue([]),
+        listRunningIssueUrls: jest.fn().mockReturnValue([]),
+      },
+    );
+
+  it('looks up related open pull requests for issue urls concurrently up to the configured limit', async () => {
+    const issueUrls = Array.from(
+      { length: 20 },
+      (_, index) => `https://github.com/owner/repo/issues/${index + 1}`,
+    );
+    let inFlightCount = 0;
+    let observedMaxInFlight = 0;
+    const findRelatedOpenPRs = jest.fn(async (issueUrl: string) => {
+      inFlightCount += 1;
+      observedMaxInFlight = Math.max(observedMaxInFlight, inFlightCount);
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      inFlightCount -= 1;
+      return [buildRelatedPullRequest(issueUrl.replace('/issues/', '/pull/'))];
+    });
+    const useCase = buildUseCase({ findRelatedOpenPRs });
+
+    const branchSources =
+      await useCase.fetchSpawnCandidateBranchSources(issueUrls);
+
+    expect(findRelatedOpenPRs).toHaveBeenCalledTimes(20);
+    expect(observedMaxInFlight).toBe(SPAWN_CANDIDATE_BRANCH_SOURCE_CONCURRENCY);
+    expect(branchSources.size).toBe(20);
+    for (const issueUrl of issueUrls) {
+      expect(branchSources.get(issueUrl)?.relatedOpenPullRequests).toHaveLength(
+        1,
+      );
+      expect(branchSources.get(issueUrl)?.openPullRequest).toBeNull();
+    }
+  });
+
+  it('resolves pull request urls through the open pull request lookup instead of the timeline query', async () => {
+    const prUrl = 'https://github.com/owner/repo/pull/7';
+    const openPullRequest = buildRelatedPullRequest(prUrl);
+    const getOpenPullRequest = jest.fn().mockResolvedValue(openPullRequest);
+    const findRelatedOpenPRs = jest.fn();
+    const useCase = buildUseCase({ getOpenPullRequest, findRelatedOpenPRs });
+
+    const branchSources = await useCase.fetchSpawnCandidateBranchSources([
+      prUrl,
+    ]);
+
+    expect(getOpenPullRequest).toHaveBeenCalledWith(prUrl);
+    expect(findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(branchSources.get(prUrl)?.openPullRequest).toBe(openPullRequest);
+    expect(branchSources.get(prUrl)?.relatedOpenPullRequests).toEqual([]);
+  });
+});

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -1,4 +1,8 @@
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import {
+  IssueRepository,
+  RelatedPullRequest,
+} from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
 import { ClaudeTokenUsageRepository } from './adapter-interfaces/ClaudeTokenUsageRepository';
@@ -19,6 +23,19 @@ const SEVEN_DAY_THROTTLE_START_THRESHOLD = 0.8;
 const FIVE_HOUR_THROTTLE_START_THRESHOLD = 0.8;
 export const DEFAULT_FALLBACK_LLM_MODEL_NAME = 'claude-opus-4-8';
 const LLM_AGENT_LABEL_PREFIX = 'llm-agent:';
+export const SPAWN_CANDIDATE_BRANCH_SOURCE_CONCURRENCY = 8;
+
+export type SpawnCandidateExclusionReason =
+  | 'dependedIssueUrls'
+  | 'futureNextActionDate'
+  | 'nextActionHourNotReached'
+  | 'authorNotAllowed'
+  | 'notAssignedToManager';
+
+export type SpawnCandidateBranchSource = {
+  openPullRequest: RelatedPullRequest | null;
+  relatedOpenPullRequests: RelatedPullRequest[];
+};
 
 export const agentNameFromDesignation = (designation: string): string =>
   designation.startsWith(LLM_AGENT_LABEL_PREFIX)
@@ -173,6 +190,79 @@ export class StartPreparationUseCase {
     );
   };
 
+  spawnCandidateExclusionReasonOf = (
+    issue: Issue,
+    allowedIssueAuthors: string[] | null,
+    manager: string,
+    now: Date,
+  ): SpawnCandidateExclusionReason | null => {
+    if (issue.dependedIssueUrls.length > 0) {
+      return 'dependedIssueUrls';
+    }
+    if (issueReactivationTriggerIsPending(issue, now)) {
+      const startOfTomorrow = new Date(
+        Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1),
+      );
+      return issue.nextActionDate !== null &&
+        issue.nextActionDate >= startOfTomorrow
+        ? 'futureNextActionDate'
+        : 'nextActionHourNotReached';
+    }
+    if (
+      allowedIssueAuthors === null ||
+      allowedIssueAuthors.length === 0 ||
+      !allowedIssueAuthors.includes(issue.author)
+    ) {
+      return 'authorNotAllowed';
+    }
+    if (!issue.assignees.includes(manager)) {
+      return 'notAssignedToManager';
+    }
+    return null;
+  };
+
+  fetchSpawnCandidateBranchSources = async (
+    issueUrls: string[],
+  ): Promise<Map<string, SpawnCandidateBranchSource>> => {
+    const branchSourceByIssueUrl = new Map<
+      string,
+      SpawnCandidateBranchSource
+    >();
+    let nextIndex = 0;
+    const fetchSequentially = async (): Promise<void> => {
+      while (nextIndex < issueUrls.length) {
+        const issueUrl = issueUrls[nextIndex];
+        nextIndex += 1;
+        branchSourceByIssueUrl.set(
+          issueUrl,
+          issueUrl.includes('/pull/')
+            ? {
+                openPullRequest:
+                  await this.issueRepository.getOpenPullRequest(issueUrl),
+                relatedOpenPullRequests: [],
+              }
+            : {
+                openPullRequest: null,
+                relatedOpenPullRequests:
+                  await this.issueRepository.findRelatedOpenPRs(issueUrl),
+              },
+        );
+      }
+    };
+    await Promise.all(
+      Array.from(
+        {
+          length: Math.min(
+            SPAWN_CANDIDATE_BRANCH_SOURCE_CONCURRENCY,
+            issueUrls.length,
+          ),
+        },
+        fetchSequentially,
+      ),
+    );
+    return branchSourceByIssueUrl;
+  };
+
   private selectRotationTokens = (
     tokenUsages: ClaudeTokenUsage[],
     utilizationPercentageThreshold: number,
@@ -427,6 +517,7 @@ export class StartPreparationUseCase {
     let updatedCurrentPreparationIssueCount = currentPreparationIssueCount;
     let startedInThisRunCount = 0;
     const spawnedInThisRunByToken: Record<string, number> = {};
+    let tokenInFlightCountsRefreshed = false;
     const exclusionCounts = {
       dependedIssueUrls: 0,
       futureNextActionDate: 0,
@@ -437,6 +528,21 @@ export class StartPreparationUseCase {
 
     const now = new Date();
 
+    const branchSourceByIssueUrl = await this.fetchSpawnCandidateBranchSources(
+      awaitingWorkspaceIssues
+        .filter(
+          (issue) =>
+            !runningIssueUrls.has(issue.url) &&
+            this.spawnCandidateExclusionReasonOf(
+              issue,
+              params.allowedIssueAuthors,
+              params.manager,
+              now,
+            ) === null,
+        )
+        .map((issue) => issue.url),
+    );
+
     for (
       let i = 0;
       i < awaitingWorkspaceIssues.length &&
@@ -452,34 +558,21 @@ export class StartPreparationUseCase {
         console.warn(`Skipping ${issue.url}: worker already running.`);
         continue;
       }
-      if (issueReactivationTriggerIsPending(issue, now)) {
-        const startOfTomorrow = new Date(
-          Date.UTC(
-            now.getUTCFullYear(),
-            now.getUTCMonth(),
-            now.getUTCDate() + 1,
-          ),
-        );
-        if (
-          issue.nextActionDate !== null &&
-          issue.nextActionDate >= startOfTomorrow
-        ) {
-          exclusionCounts.futureNextActionDate++;
-        } else {
-          exclusionCounts.nextActionHourNotReached++;
-        }
-        continue;
-      }
-      if (
-        params.allowedIssueAuthors === null ||
-        params.allowedIssueAuthors.length === 0 ||
-        !params.allowedIssueAuthors.includes(issue.author)
-      ) {
-        exclusionCounts.authorNotAllowed++;
+      const exclusionReason = this.spawnCandidateExclusionReasonOf(
+        issue,
+        params.allowedIssueAuthors,
+        params.manager,
+        now,
+      );
+      if (exclusionReason !== null) {
+        exclusionCounts[exclusionReason]++;
         continue;
       }
-      if (!issue.assignees.includes(params.manager)) {
-        exclusionCounts.notAssignedToManager++;
+      const branchSource = branchSourceByIssueUrl.get(issue.url);
+      if (branchSource === undefined) {
+        console.error(
+          `Skipping ${issue.url}: no branch source was prefetched for this spawn candidate.`,
+        );
         continue;
       }
       await adoptIssueAgentDesignationLabel(
@@ -538,7 +631,7 @@ export class StartPreparationUseCase {
       const isPrUrl = issue.url.includes('/pull/');
       let branchName: string;
       if (isPrUrl) {
-        const pr = await this.issueRepository.getOpenPullRequest(issue.url);
+        const pr = branchSource.openPullRequest;
         if (pr === null) {
           console.warn(
             `Skipping non-OPEN PR ${issue.url}: wrapper requires an open PR.`,
@@ -551,9 +644,7 @@ export class StartPreparationUseCase {
         }
         branchName = pr.branchName;
       } else {
-        const relatedPRs = await this.issueRepository.findRelatedOpenPRs(
-          issue.url,
-        );
+        const relatedPRs = branchSource.relatedOpenPullRequests;
         const sameRepoRelatedPRs = relatedPRs.filter((pr) => {
           const match = /^https?:\/\/[^/]+\/([^/]+\/[^/]+)\//.exec(pr.url);
           return match === null || match[1] === issue.nameWithOwner;
@@ -640,23 +731,39 @@ export class StartPreparationUseCase {
       let routedModelName: string | null = null;
       let selectedTokenName: string | null = null;
       if (rotationTokens !== null && proxyBaseUrl !== null) {
-        const tokenWithSoonestResetAmongAvailable = selectedTokensWithLimits
-          .map((t) => ({
-            token: t.token,
-            model: t.model,
-            remaining:
-              t.limit -
-              (tokenInFlightCounts[t.token] ?? 0) -
-              (spawnedInThisRunByToken[t.token] ?? 0),
-            secondsUntilSevenDayReset: t.secondsUntilSevenDayReset,
-          }))
-          .filter((t) => t.remaining > 0)
-          .sort((a, b) => {
-            if (a.secondsUntilSevenDayReset !== b.secondsUntilSevenDayReset) {
-              return a.secondsUntilSevenDayReset - b.secondsUntilSevenDayReset;
-            }
-            return b.remaining - a.remaining;
-          })[0];
+        const tokenWithSoonestResetAmongAvailableOf = ():
+          { token: string; model: string } | undefined =>
+          selectedTokensWithLimits
+            .map((t) => ({
+              token: t.token,
+              model: t.model,
+              remaining:
+                t.limit -
+                (tokenInFlightCounts[t.token] ?? 0) -
+                (spawnedInThisRunByToken[t.token] ?? 0),
+              secondsUntilSevenDayReset: t.secondsUntilSevenDayReset,
+            }))
+            .filter((t) => t.remaining > 0)
+            .sort((a, b) => {
+              if (a.secondsUntilSevenDayReset !== b.secondsUntilSevenDayReset) {
+                return (
+                  a.secondsUntilSevenDayReset - b.secondsUntilSevenDayReset
+                );
+              }
+              return b.remaining - a.remaining;
+            })[0];
+        let tokenWithSoonestResetAmongAvailable =
+          tokenWithSoonestResetAmongAvailableOf();
+        if (
+          tokenWithSoonestResetAmongAvailable === undefined &&
+          !tokenInFlightCountsRefreshed
+        ) {
+          tokenInFlightCountsRefreshed = true;
+          tokenInFlightCounts =
+            await this.claudeTokenUsageRepository.getTokenInFlightCounts();
+          tokenWithSoonestResetAmongAvailable =
+            tokenWithSoonestResetAmongAvailableOf();
+        }
         if (tokenWithSoonestResetAmongAvailable === undefined) {
           await revertToAwaitingWorkspace(
             'every Claude OAuth token reached its concurrent worker limit',

package/src/domain/usecases/adapter-interfaces/LocalCommandRunner.ts

@@ -12,4 +12,5 @@ export interface LocalCommandRunner {
     stderr: string;
     exitCode: number;
   }>;
+  spawnInteractive(program: string, args: string[]): void;
 }

package/src/domain/usecases/adapter-interfaces/TmuxSessionRepository.ts

@@ -13,4 +13,8 @@ export interface TmuxSessionRepository {
   killOwnSession: () => Promise<void>;
   sendKeys: (sessionName: string, literalText: string) => Promise<void>;
   launchBareNameLeaderSession: (name: string) => Promise<void>;
+  attachOrCreateInteractiveSession: (
+    issueUrl: string,
+    scopeLibPath: string | null,
+  ) => Promise<void>;
 }

package/src/domain/usecases/console/GenerateConsoleListsUseCase.test.ts

@@ -800,19 +800,20 @@ describe('GenerateConsoleListsUseCase', () => {
   });
 
   describe('stories tab', () => {
-    it('includes one entry per non-GRAY story option', () => {
+    it('includes one entry per story option including GRAY', () => {
       const result = run([]);
-      expect(result.stories.stories).toHaveLength(2);
+      expect(result.stories.stories).toHaveLength(3);
       expect(result.stories.stories.map((s) => s.storyName)).toEqual([
+        'regular / NO STORY; SET STORY FIELD',
         'Story Alpha',
         'Story Beta',
       ]);
     });
 
-    it('excludes story options whose color is GRAY', () => {
+    it('includes story options whose color is GRAY', () => {
       const result = run([]);
       const names = result.stories.stories.map((s) => s.storyName);
-      expect(names).not.toContain('regular / NO STORY; SET STORY FIELD');
+      expect(names).toContain('regular / NO STORY; SET STORY FIELD');
     });
 
     it('counts open items per story from all open issues on the board', () => {

package/src/domain/usecases/console/GenerateConsoleListsUseCase.ts

@@ -173,17 +173,15 @@ export class GenerateConsoleListsUseCase {
     const defaultNameWithOwner =
       issues.find((issue) => issue.nameWithOwner !== '')?.nameWithOwner ?? null;
 
-    const storyEntries: ConsoleStoryEntry[] = storyOptions
-      .filter((option) => option.color !== 'GRAY')
-      .map((option) => ({
-        storyName: option.name,
-        storyOptionId: option.id,
-        color: option.color,
-        openItemCount: openItemCountByStory.get(option.name) ?? 0,
-        storyViewUrl: urlOfStoryView
-          ? `${urlOfStoryView}?sliceBy%5Bvalue%5D=${encodeForURI(option.name)}`
-          : null,
-      }));
+    const storyEntries: ConsoleStoryEntry[] = storyOptions.map((option) => ({
+      storyName: option.name,
+      storyOptionId: option.id,
+      color: option.color,
+      openItemCount: openItemCountByStory.get(option.name) ?? 0,
+      storyViewUrl: urlOfStoryView
+        ? `${urlOfStoryView}?sliceBy%5Bvalue%5D=${encodeForURI(option.name)}`
+        : null,
+    }));
 
     return {
       'workflow-blocker': buildStatusTabFromSource(

package/src/domain/usecases/dashboard/GenerateTokenStatusUseCase.test.ts

@@ -111,6 +111,7 @@ const snapshot = (
   sevenDaySonnetRejected: false,
   sevenDayOpusRejected: false,
   hasWindowData: true,
+  lastUpdatedEpoch: 1_000_000,
   ...overrides,
 });
 
@@ -280,3 +281,65 @@ describe('computeSevenDayWindowAggregate', () => {
     expect(computeSevenDayWindowAggregate([])).toBeNull();
   });
 });
+
+describe('GenerateTokenStatusUseCase window rollover inference', () => {
+  const usecase = new GenerateTokenStatusUseCase();
+  const now = 2_000_000;
+
+  const runFor = (
+    snapshotOverrides: Partial<TokenRateLimitSnapshot>,
+  ): TokenStatus =>
+    usecase.run({
+      tokens: [
+        {
+          name: 'alice',
+          token: 'token-a',
+          snapshot: snapshot(snapshotOverrides),
+        },
+      ],
+      prepCountByToken: new Map(),
+      humCountByToken: new Map(),
+      nowEpochSeconds: now,
+    })[0];
+
+  it('keeps the last observed utilization when the snapshot predates the reset it reports', () => {
+    const result = runFor({
+      sevenDayUtilization: 0.98,
+      sevenDayReset: now - 3600,
+      lastUpdatedEpoch: now - 72000,
+    });
+
+    expect(result.sevenDayUtilizationPercent).toBe(98);
+  });
+
+  it('keeps a seven day rejection visible when the snapshot predates the reset it reports', () => {
+    const result = runFor({
+      sevenDayUtilization: 0.98,
+      sevenDayReset: now - 3600,
+      sevenDayRejected: true,
+      lastUpdatedEpoch: now - 72000,
+    });
+
+    expect(result.color).toBe('K');
+  });
+
+  it('reports a rolled over window as unused when the snapshot was captured after that reset', () => {
+    const result = runFor({
+      sevenDayUtilization: 0.98,
+      sevenDayReset: now - 3600,
+      lastUpdatedEpoch: now - 1800,
+    });
+
+    expect(result.sevenDayUtilizationPercent).toBe(0);
+  });
+
+  it('keeps the last observed five hour utilization when the snapshot predates the five hour reset', () => {
+    const result = runFor({
+      fiveHourUtilization: 0.91,
+      fiveHourReset: now - 600,
+      lastUpdatedEpoch: now - 72000,
+    });
+
+    expect(result.fiveHourUtilizationPercent).toBe(91);
+  });
+});