github-issue-tower-defence-management 1.141.0 → 1.142.0

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

@@ -1,8 +1,21 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { TranscriptOwnerCallStatusProvider } from './TranscriptOwnerCallStatusProvider';
+import {
+  TranscriptOwnerCallStatusProvider,
+  ownerCallMarkerFamilyResolve,
+} from './TranscriptOwnerCallStatusProvider';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
+import {
+  NotifySilentLiveSessionsUseCase,
+  DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+  DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+  DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+  DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+  DEFAULT_NOTIFICATION_STAGGER_SECONDS,
+  DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
+  DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
+} from '../../domain/usecases/NotifySilentLiveSessionsUseCase';
 
 describe('TranscriptOwnerCallStatusProvider', () => {
   let rootDirectory: string;
@@ -122,6 +135,8 @@ describe('TranscriptOwnerCallStatusProvider', () => {
 
   const sessionName = 'workbench';
 
+  const TERMINATORLESS_MARKER = 'OWNER-CALL';
+
   it('reports a session as waiting when the last owner call is newer than the last owner reply', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       ownerReply('2026-06-27T10:00:00.000Z'),
@@ -384,6 +399,182 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     expect(result.has(sessionName)).toBe(true);
   });
 
+  it('detects an owner call raised with the candidate tag family while the configured marker names the legacy literal family', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      ownerReply('2026-06-27T10:00:00.000Z'),
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: '<call-to-user-pending>Please decide.</call-to-user-pending>',
+            },
+          ],
+        },
+      },
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.get(sessionName)).toBe(
+      Math.floor(Date.parse('2026-06-27T10:05:00.000Z') / 1000),
+    );
+  });
+
+  it('treats a later genuine owner reply as answering a candidate-tag owner call', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:00:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: '<call-to-user-pending>Decide.</call-to-user-pending>',
+            },
+          ],
+        },
+      },
+      ownerReply('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.has(sessionName)).toBe(false);
+  });
+
+  it('keeps detecting an owner call raised with the legacy literal tag family', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      ownerReply('2026-06-27T10:00:00.000Z'),
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: '<call-to-user>Please decide.</call-to-user>',
+            },
+          ],
+        },
+      },
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.get(sessionName)).toBe(
+      Math.floor(Date.parse('2026-06-27T10:05:00.000Z') / 1000),
+    );
+  });
+
+  it('reports the latest call when the legacy tag precedes a candidate tag', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T09:00:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: '<call-to-user>First.</call-to-user>' },
+          ],
+        },
+      },
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: '<call-to-user-pending>Second.</call-to-user-pending>',
+            },
+          ],
+        },
+      },
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.get(sessionName)).toBe(
+      Math.floor(Date.parse('2026-06-27T10:05:00.000Z') / 1000),
+    );
+  });
+
+  it('does not treat an unrelated tag that merely shares the marker prefix as an owner call', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: '<call-to-user-draft>Not a call.</call-to-user-draft>',
+            },
+          ],
+        },
+      },
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.has(sessionName)).toBe(false);
+  });
+
+  it('treats a marker that does not end with the tag terminator as an owner call marker in its own right', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: `${TERMINATORLESS_MARKER} please decide` },
+          ],
+        },
+      },
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      TERMINATORLESS_MARKER,
+    );
+
+    const result =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+    expect(result.get(sessionName)).toBe(
+      Math.floor(Date.parse('2026-06-27T10:05:00.000Z') / 1000),
+    );
+  });
+
   it('uses the canonical call-to-user marker string', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       {
@@ -405,3 +596,179 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     expect(result.has(sessionName)).toBe(true);
   });
 });
+
+describe('ownerCallMarkerFamilyResolve', () => {
+  const TERMINATORLESS_MARKER = 'OWNER-CALL';
+  const CLOSED_TAG_MARKER = `<${TERMINATORLESS_MARKER}>`;
+
+  it('resolves a closed-tag marker to that tag and its candidate form', () => {
+    expect(ownerCallMarkerFamilyResolve(CLOSED_TAG_MARKER)).toEqual([
+      CLOSED_TAG_MARKER,
+      `<${TERMINATORLESS_MARKER}-pending>`,
+    ]);
+  });
+
+  it('resolves the deployed legacy owner-call tag to both tag families', () => {
+    expect(ownerCallMarkerFamilyResolve('<call-to-user>')).toEqual([
+      '<call-to-user>',
+      '<call-to-user-pending>',
+    ]);
+  });
+
+  it('resolves a marker that does not end with the tag terminator to that marker alone', () => {
+    expect(ownerCallMarkerFamilyResolve(TERMINATORLESS_MARKER)).toEqual([
+      TERMINATORLESS_MARKER,
+    ]);
+  });
+});
+
+describe('TranscriptOwnerCallStatusProvider wired into NotifySilentLiveSessionsUseCase', () => {
+  let rootDirectory: string;
+
+  beforeEach(() => {
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'owner-call-suppression-'),
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const now = new Date('2026-06-27T11:00:00.000Z');
+  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
+  const monitoredSessionName =
+    'https_//github_com/HiromiShikata/repo/issues/42';
+
+  class EveryNameRecentSet extends Set<string> {
+    override has = (): boolean => true;
+  }
+
+  const assistantEntryWith = (text: string): object => ({
+    type: 'assistant',
+    timestamp: '2026-06-27T10:30:00.000Z',
+    message: {
+      role: 'assistant',
+      stop_reason: 'end_turn',
+      content: [{ type: 'text', text }],
+    },
+  });
+
+  const runUseCaseWithTranscript = async (
+    entries: object[],
+  ): Promise<jest.Mock> => {
+    const transcriptPath = path.join(rootDirectory, 'session.jsonl');
+    fs.writeFileSync(
+      transcriptPath,
+      entries.map((entry) => JSON.stringify(entry)).join('\n'),
+      'utf8',
+    );
+    const sendSelfCheckNotification = jest.fn().mockResolvedValue(undefined);
+    const useCase = new NotifySilentLiveSessionsUseCase(
+      {
+        getSnapshot: jest.fn().mockResolvedValue({
+          sessions: [{ sessionName: monitoredSessionName, panePids: [100] }],
+          processes: [
+            {
+              pid: 101,
+              ppid: 100,
+              commandLine: `claude --name ${monitoredSessionName}`,
+              sessionId: 'session-uuid',
+              currentSessionId: 'session-uuid',
+              configDir: '/config/session',
+            },
+          ],
+        }),
+      },
+      {
+        resolveTranscriptPaths: jest
+          .fn()
+          .mockReturnValue(new Map([[monitoredSessionName, transcriptPath]])),
+      },
+      {
+        listSessionOutputActivities: jest.fn().mockResolvedValue([
+          {
+            sessionName: monitoredSessionName,
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ]),
+      },
+      {
+        listSubAgentActivitiesBySessionName: jest
+          .fn()
+          .mockResolvedValue(new Map()),
+      },
+      new TranscriptOwnerCallStatusProvider('<call-to-user>'),
+      { sendSelfCheckNotification },
+      {
+        loadRecentCandidateSessionNames: jest
+          .fn()
+          .mockResolvedValue(new EveryNameRecentSet()),
+        saveCandidateSessionNames: jest.fn().mockResolvedValue(undefined),
+      },
+      {
+        loadRecentNotifiedSessionNames: jest
+          .fn()
+          .mockResolvedValue(new Set<string>()),
+        saveNotifiedSessionNames: jest.fn().mockResolvedValue(undefined),
+      },
+      {
+        composeMainStalledSection: jest.fn().mockReturnValue('MAIN_STALLED'),
+        composeMainStalledWithStaleOwnerCallSection: jest
+          .fn()
+          .mockReturnValue('MAIN_STALLED_STALE'),
+        composeSubAgentSection: jest.fn().mockReturnValue('SUBAGENT'),
+      },
+      { sleep: jest.fn().mockResolvedValue(undefined) },
+    );
+
+    await useCase.run({
+      mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+      unansweredOwnerCallGraceSeconds:
+        DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+      subAgentSilentThresholdSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+      subAgentRunningThresholdSeconds:
+        DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+      staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
+      candidateDebounceRecencyWindowSeconds:
+        DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
+      activeHubTaskStatus: null,
+      hubTaskStatusCacheTtlSeconds: DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
+      now,
+    });
+
+    return sendSelfCheckNotification;
+  };
+
+  it('suppresses the silent-session reminder for a session whose only owner call uses the candidate tag family', async () => {
+    const sendSelfCheckNotification = await runUseCaseWithTranscript([
+      assistantEntryWith(
+        '<call-to-user-pending>Please decide.</call-to-user-pending>',
+      ),
+    ]);
+
+    expect(sendSelfCheckNotification).not.toHaveBeenCalled();
+  });
+
+  it('suppresses the silent-session reminder for a session whose only owner call uses the legacy literal tag family', async () => {
+    const sendSelfCheckNotification = await runUseCaseWithTranscript([
+      assistantEntryWith('<call-to-user>Please decide.</call-to-user>'),
+    ]);
+
+    expect(sendSelfCheckNotification).not.toHaveBeenCalled();
+  });
+
+  it('still sends the silent-session reminder for a silent session that raised no owner call', async () => {
+    const sendSelfCheckNotification = await runUseCaseWithTranscript([
+      assistantEntryWith('progress update'),
+    ]);
+
+    expect(sendSelfCheckNotification).toHaveBeenCalledWith(
+      monitoredSessionName,
+      'MAIN_STALLED',
+    );
+  });
+});

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -88,8 +88,27 @@ const hasOwnerTextReply = (content: unknown): boolean => {
   return !extractText(content).includes(SILENT_SESSION_REMINDER_SENTINEL);
 };
 
+const OWNER_CALL_TAG_TERMINATOR = '>';
+const OWNER_CALL_CANDIDATE_TAG_INFIX = '-pending';
+const OWNER_CALL_CANDIDATE_TAG_SUFFIX = `${OWNER_CALL_CANDIDATE_TAG_INFIX}${OWNER_CALL_TAG_TERMINATOR}`;
+
+export const ownerCallMarkerFamilyResolve = (marker: string): string[] =>
+  marker.endsWith(OWNER_CALL_TAG_TERMINATOR)
+    ? [
+        marker,
+        `${marker.slice(0, -OWNER_CALL_TAG_TERMINATOR.length)}${OWNER_CALL_CANDIDATE_TAG_SUFFIX}`,
+      ]
+    : [marker];
+
 export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
-  constructor(private readonly ownerCallMarker: string | null) {}
+  private readonly ownerCallMarkerFamily: string[];
+
+  constructor(ownerCallMarker: string | null) {
+    this.ownerCallMarkerFamily =
+      ownerCallMarker === null || ownerCallMarker.length === 0
+        ? []
+        : ownerCallMarkerFamilyResolve(ownerCallMarker);
+  }
 
   listUnansweredOwnerCallEpochSecondsBySessionName = async (
     transcriptPathBySessionName: Map<string, string>,
@@ -98,14 +117,13 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
       string,
       number
     >();
-    if (this.ownerCallMarker === null || this.ownerCallMarker.length === 0) {
+    if (this.ownerCallMarkerFamily.length === 0) {
       return unansweredOwnerCallEpochSecondsBySessionName;
     }
-    const marker = this.ownerCallMarker;
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
       const unansweredOwnerCallEpochMs = this.findUnansweredOwnerCallEpochMs(
         transcriptPath,
-        marker,
+        this.ownerCallMarkerFamily,
       );
       if (unansweredOwnerCallEpochMs !== null) {
         unansweredOwnerCallEpochSecondsBySessionName.set(
@@ -119,7 +137,7 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
 
   private findUnansweredOwnerCallEpochMs = (
     transcriptPath: string,
-    marker: string,
+    markerFamily: string[],
   ): number | null => {
     let content: string;
     try {
@@ -150,11 +168,11 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
       const type = readString(parsed, 'type');
       const message = parsed.message;
       const messageContent = isRecord(message) ? message.content : null;
-      if (
-        type === 'assistant' &&
-        extractText(messageContent).includes(marker)
-      ) {
-        lastOwnerCallEpochMs = epochMs;
+      if (type === 'assistant') {
+        const assistantText = extractText(messageContent);
+        if (markerFamily.some((marker) => assistantText.includes(marker))) {
+          lastOwnerCallEpochMs = epochMs;
+        }
       }
       if (
         type === 'user' &&

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

@@ -3002,6 +3002,37 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         ),
       );
     });
+
+    it('reports isCiStateSuccess true when an older check-run record with the same name has failure but the newer record has success', async () => {
+      mockFetchRoutes({
+        timeline: () => buildSlimTimelineResponse(),
+        slimPullRequest: () =>
+          buildSlimPullRequestResponse({
+            url: 'https://github.com/HiromiShikata/test-repository/pull/11148',
+            reviewThreads: {
+              pageInfo: { endCursor: null, hasNextPage: false },
+              nodes: [],
+            },
+          }),
+        branchRules: () => [],
+        checkRuns: () => ({
+          total_count: 2,
+          check_runs: [
+            { id: 100, name: 'ci', conclusion: 'failure' },
+            { id: 200, name: 'ci', conclusion: 'success' },
+          ],
+        }),
+      });
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.findRelatedOpenPRs(
+        'https://github.com/HiromiShikata/test-repository/issues/11194',
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].isCiStateSuccess).toBe(true);
+      expect(result[0].isPassedAllCiJob).toBe(true);
+    });
   });
 
   describe('findRelatedOpenPRs cross-repo PR', () => {

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

@@ -6,6 +6,7 @@ import {
   formatProjectHeaderLine,
   formatProjectRowLine,
   formatResetCountdown,
+  formatSevenDayWindowAggregateLine,
   formatTokenRowLine,
   roundHalfToEven,
 } from './ComposeDashboardUseCase';
@@ -485,3 +486,166 @@ describe('ComposeDashboardUseCase', () => {
     }
   });
 });
+
+describe('formatSevenDayWindowAggregateLine', () => {
+  const columnEnd = (line: string, field: string): number =>
+    codePointLength(line.slice(0, line.indexOf(field) + field.length));
+
+  it('renders only the remaining percentage, without a count when every token is included', () => {
+    expect(
+      formatSevenDayWindowAggregateLine({
+        usedPercent: 63,
+        includedTokenCount: 10,
+        totalTokenCount: 10,
+      }),
+    ).toBe('7d                  37%');
+  });
+
+  it('aligns the remaining percentage under the seven day column of the token rows', () => {
+    const tokenRow = formatTokenRowLine(
+      tokenStatus({
+        name: 'dev4',
+        color: 'K',
+        fiveHourUtilizationPercent: 0,
+        fiveHourResetSeconds: 60,
+        sevenDayUtilizationPercent: 100,
+        sevenDayResetSeconds: 96060,
+      }),
+    );
+    const aggregateLine = formatSevenDayWindowAggregateLine({
+      usedPercent: 63.36,
+      includedTokenCount: 11,
+      totalTokenCount: 11,
+    });
+    expect(tokenRow).toBe('⚪dev4   0% 0d00h01 100% 1d02h41 0 0');
+    expect(aggregateLine).toBe('7d                  37%');
+    expect(columnEnd(aggregateLine ?? '', '37%')).toBe(
+      columnEnd(tokenRow, '100%'),
+    );
+  });
+
+  it('keeps the alignment when the remaining percentage needs fewer digits', () => {
+    const wide = formatSevenDayWindowAggregateLine({
+      usedPercent: 0,
+      includedTokenCount: 1,
+      totalTokenCount: 1,
+    });
+    const narrow = formatSevenDayWindowAggregateLine({
+      usedPercent: 95,
+      includedTokenCount: 1,
+      totalTokenCount: 1,
+    });
+    expect(wide).toBe('7d                 100%');
+    expect(narrow).toBe('7d                   5%');
+    expect(codePointLength(wide ?? '')).toBe(codePointLength(narrow ?? ''));
+  });
+
+  it('appends the included token count when some tokens have no value', () => {
+    expect(
+      formatSevenDayWindowAggregateLine({
+        usedPercent: 63,
+        includedTokenCount: 9,
+        totalTokenCount: 10,
+      }),
+    ).toBe('7d                  37% (9)');
+  });
+
+  it('rounds the remaining percentage with half-to-even before rendering', () => {
+    expect(
+      formatSevenDayWindowAggregateLine({
+        usedPercent: 62.5,
+        includedTokenCount: 2,
+        totalTokenCount: 2,
+      }),
+    ).toBe('7d                  38%');
+    expect(
+      formatSevenDayWindowAggregateLine({
+        usedPercent: 63.5,
+        includedTokenCount: 2,
+        totalTokenCount: 2,
+      }),
+    ).toBe('7d                  36%');
+  });
+
+  it('renders nothing when the aggregate is absent', () => {
+    expect(formatSevenDayWindowAggregateLine(null)).toBeNull();
+  });
+
+  it('fits the width budget at the widest rendering', () => {
+    const line = formatSevenDayWindowAggregateLine({
+      usedPercent: 0,
+      includedTokenCount: 999,
+      totalTokenCount: 1000,
+    });
+    expect(line).toBe('7d                 100% (999)');
+    expect(codePointLength(line ?? '')).toBeLessThanOrEqual(
+      PROJECT_ROW_WIDTH_BUDGET,
+    );
+  });
+});
+
+describe('ComposeDashboardUseCase seven day window aggregate line', () => {
+  const aggregateInput = (
+    sevenDayWindowAggregate: ComposeDashboardInput['sevenDayWindowAggregate'],
+  ): ComposeDashboardInput => ({
+    machineStatus: null,
+    projects: [{ code: 'um', row: projectRow({ unread: 1 }) }],
+    tokens: [
+      tokenStatus({ name: 'alice', sevenDayUtilizationPercent: 60 }),
+      tokenStatus({ name: 'bob', sevenDayUtilizationPercent: 66 }),
+    ],
+    sevenDayWindowAggregate,
+  });
+
+  const unwrappedLines = (output: string): string[] =>
+    output
+      .split('\n')
+      .filter((line) => line.length > 0)
+      .map((line) =>
+        line
+          .replace(/^<tt>/, '')
+          .replace(/<\/tt><br>$/, '')
+          .replace(/&nbsp;/g, ' '),
+      );
+
+  it('places the aggregate line immediately above the token rows', () => {
+    const lines = unwrappedLines(
+      new ComposeDashboardUseCase().run(
+        aggregateInput({
+          usedPercent: 63,
+          includedTokenCount: 2,
+          totalTokenCount: 2,
+        }),
+      ),
+    );
+    const aggregateIndex = lines.indexOf('7d                  37%');
+    expect(aggregateIndex).toBeGreaterThan(-1);
+    expect(lines[aggregateIndex - 1]).toBe(
+      formatProjectRowLine({
+        code: 'um',
+        row: projectRow({ unread: 1 }),
+      }),
+    );
+    expect(lines[aggregateIndex + 1]).toContain('alice');
+  });
+
+  it('keeps the blank separator line when the aggregate is absent', () => {
+    const lines = unwrappedLines(
+      new ComposeDashboardUseCase().run(aggregateInput(null)),
+    );
+    expect(lines.some((line) => line.startsWith('7d '))).toBe(false);
+    expect(lines).toContain('');
+  });
+
+  it('keeps the blank separator line when the aggregate field is missing entirely', () => {
+    const lines = unwrappedLines(
+      new ComposeDashboardUseCase().run({
+        machineStatus: null,
+        projects: [],
+        tokens: [tokenStatus({ name: 'alice' })],
+      }),
+    );
+    expect(lines.some((line) => line.startsWith('7d '))).toBe(false);
+    expect(lines).toContain('');
+  });
+});