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

package/src/adapter/entry-points/console/dashboardComposeService.test.ts

@@ -233,6 +233,88 @@ describe('buildComposeDashboardInput', () => {
     }
   });
 
+  it('reads the seven day window aggregate from token-status.json', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [],
+          sevenDayWindowAggregate: {
+            usedPercent: 63.5,
+            includedTokenCount: 9,
+            totalTokenCount: 10,
+          },
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectNames: [],
+      });
+      expect(input.sevenDayWindowAggregate).toEqual({
+        usedPercent: 63.5,
+        includedTokenCount: 9,
+        totalTokenCount: 10,
+      });
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('reads a token-status.json written without the seven day window aggregate', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [
+            {
+              name: 'alice',
+              fiveHourUtilizationPercent: 10,
+              fiveHourResetSeconds: 3600,
+              sevenDayUtilizationPercent: 12,
+              sevenDayResetSeconds: 432000,
+              color: 'G',
+              prep: 2,
+              hum: 1,
+            },
+          ],
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectNames: [],
+      });
+      expect(input.sevenDayWindowAggregate).toBeNull();
+      expect(input.tokens).toHaveLength(1);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('ignores a seven day window aggregate with a missing field', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [],
+          sevenDayWindowAggregate: { usedPercent: 63 },
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectNames: [],
+      });
+      expect(input.sevenDayWindowAggregate).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
   it('defaults an unknown token color to Y and null windows to null', () => {
     const dataDir = makeDataDir();
     try {

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

@@ -10,6 +10,7 @@ import {
 import { toDashboardDisplayLabel } from '../../../domain/usecases/dashboard/DashboardProjectCode';
 import { DashboardRow } from '../../../domain/usecases/dashboard/GenerateDashboardRowUseCase';
 import {
+  SevenDayWindowAggregate,
   TokenStatus,
   TokenStatusColor,
 } from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
@@ -163,10 +164,36 @@ const parseTokenStatus = (value: unknown): TokenStatus | null => {
   };
 };
 
-const readTokenStatuses = (dashboardDataDir: string): TokenStatus[] => {
+const parseSevenDayWindowAggregate = (
+  value: unknown,
+): SevenDayWindowAggregate | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const usedPercent = asFiniteNumber(value.usedPercent);
+  const includedTokenCount = asFiniteNumber(value.includedTokenCount);
+  const totalTokenCount = asFiniteNumber(value.totalTokenCount);
+  if (
+    usedPercent === null ||
+    includedTokenCount === null ||
+    totalTokenCount === null
+  ) {
+    return null;
+  }
+  return { usedPercent, includedTokenCount, totalTokenCount };
+};
+
+type TokenStatusFileContent = {
+  tokens: TokenStatus[];
+  sevenDayWindowAggregate: SevenDayWindowAggregate | null;
+};
+
+const readTokenStatusFile = (
+  dashboardDataDir: string,
+): TokenStatusFileContent => {
   const value = readJsonFile(path.join(dashboardDataDir, 'token-status.json'));
   if (!isRecord(value) || !Array.isArray(value.tokens)) {
-    return [];
+    return { tokens: [], sevenDayWindowAggregate: null };
   }
   const tokens: TokenStatus[] = [];
   for (const entry of value.tokens) {
@@ -175,7 +202,12 @@ const readTokenStatuses = (dashboardDataDir: string): TokenStatus[] => {
       tokens.push(token);
     }
   }
-  return tokens;
+  return {
+    tokens,
+    sevenDayWindowAggregate: parseSevenDayWindowAggregate(
+      value.sevenDayWindowAggregate,
+    ),
+  };
 };
 
 export const buildComposeDashboardInput = (
@@ -187,10 +219,12 @@ export const buildComposeDashboardInput = (
       row: readProjectRow(options.dashboardDataDir, projectName),
     }),
   );
+  const tokenStatusFile = readTokenStatusFile(options.dashboardDataDir);
   return {
     projects,
     machineStatus: readMachineStatus(options.dashboardDataDir),
-    tokens: readTokenStatuses(options.dashboardDataDir),
+    tokens: tokenStatusFile.tokens,
+    sevenDayWindowAggregate: tokenStatusFile.sevenDayWindowAggregate,
   };
 };
 

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

@@ -128,6 +128,11 @@ describe('writeTokenStatus', () => {
     const written = readJson(path.join(dir, 'token-status.json'));
     const expected: TokenStatusFile = {
       capturedAt: '2026-06-26T12:00:00.000Z',
+      sevenDayWindowAggregate: {
+        usedPercent: 50,
+        includedTokenCount: 1,
+        totalTokenCount: 2,
+      },
       tokens: [
         {
           name: 'alice',
@@ -216,6 +221,7 @@ describe('writeTokenStatus', () => {
     };
     expect(written).toEqual({
       capturedAt: '2026-06-26T12:00:00.000Z',
+      sevenDayWindowAggregate: null,
       tokens: [
         expectedAlice,
         {

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

@@ -4,9 +4,11 @@ import type { Issue } from '../../../domain/entities/Issue';
 import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
 import {
   GenerateTokenStatusUseCase,
+  SevenDayWindowAggregate,
   TokenRateLimitSnapshot,
   TokenStatus,
   TokenStatusInput,
+  computeSevenDayWindowAggregate,
 } from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
 import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
 import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
@@ -35,6 +37,7 @@ export type TokenStatusWriterParams = {
 
 export type TokenStatusFile = {
   tokens: TokenStatus[];
+  sevenDayWindowAggregate: SevenDayWindowAggregate | null;
   capturedAt: string;
 };
 
@@ -247,6 +250,7 @@ export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
 
   const file: TokenStatusFile = {
     tokens,
+    sevenDayWindowAggregate: computeSevenDayWindowAggregate(tokens),
     capturedAt: now.toISOString(),
   };
 

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

@@ -1,7 +1,10 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { FileSystemSubAgentLivenessResolver } from './FileSystemSubAgentLivenessResolver';
+import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
+import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
 
 describe('FileSystemSubAgentLivenessResolver', () => {
   let runtimeRoot: string;
@@ -40,6 +43,20 @@ describe('FileSystemSubAgentLivenessResolver', () => {
     expect(result).toEqual(new Set(['a70a08e0587d6f484', 'ad5d15d239d7e72e8']));
   });
 
+  it('returns only the leading agent id token of each record line', async () => {
+    writeRunningFile(
+      'ad3d5702d1339492e impl:redcircle-only-tag-format (no branch)\naf19c02b4c3a5d6e7 chore:board-sync i1300-record-parsing\n',
+    );
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toEqual(new Set(['ad3d5702d1339492e', 'af19c02b4c3a5d6e7']));
+  });
+
   it('returns an empty set when the running file exists but lists no ids', async () => {
     writeRunningFile('\n   \n');
     const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
@@ -85,3 +102,80 @@ describe('FileSystemSubAgentLivenessResolver', () => {
     expect(result).toBeNull();
   });
 });
+
+describe('running-subagents record agent id contract with TranscriptSessionSubAgentActivityRepository', () => {
+  const cwdSlug = '-home-user-worktrees-issue-1300';
+  const sessionUuid = 'c0f1a2b3-4d5e-6f70-8192-a3b4c5d6e7f8';
+  const sessionName = 'https_//github_com/owner/repo/issues/1300';
+  const liveAgentId = 'ad3d5702d1339492e';
+  const now = new Date('2026-07-28T12:00:00.000Z');
+  const emptyProcessLister: SubAgentProcessLister = {
+    listProcesses: async () => [],
+  };
+  let runtimeRoot: string;
+  let transcriptRoot: string;
+  let mainTranscriptPath: string;
+
+  beforeEach(() => {
+    runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-live-rt-'));
+    transcriptRoot = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'subagent-live-tx-'),
+    );
+    mainTranscriptPath = path.join(
+      transcriptRoot,
+      cwdSlug,
+      `${sessionUuid}.jsonl`,
+    );
+    fs.mkdirSync(path.dirname(mainTranscriptPath), { recursive: true });
+    fs.writeFileSync(mainTranscriptPath, '', 'utf8');
+  });
+
+  afterEach(() => {
+    fs.rmSync(runtimeRoot, { force: true, recursive: true });
+    fs.rmSync(transcriptRoot, { force: true, recursive: true });
+  });
+
+  it('keeps a sub-agent whose id is recorded together with its label on one line', async () => {
+    const runningDirectory = path.join(runtimeRoot, cwdSlug, sessionUuid);
+    fs.mkdirSync(runningDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(runningDirectory, 'running-subagents.txt'),
+      `${liveAgentId} impl:subagent-liveness-record-parsing (no branch)\n`,
+      'utf8',
+    );
+    const subAgentsDirectory = path.join(
+      transcriptRoot,
+      cwdSlug,
+      sessionUuid,
+      'subagents',
+    );
+    fs.mkdirSync(subAgentsDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(subAgentsDirectory, `agent-${liveAgentId}.jsonl`),
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: '2026-07-28T11:00:00.000Z',
+        message: {
+          stop_reason: 'tool_use',
+          content: [{ type: 'tool_use', name: 'Read', input: {} }],
+        },
+      }),
+      'utf8',
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      new FileSystemSubAgentTranscriptDirectoryResolver(transcriptRoot),
+      emptyProcessLister,
+      now,
+      new FileSystemSubAgentLivenessResolver(runtimeRoot),
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      new Map([[sessionName, mainTranscriptPath]]),
+    );
+
+    expect(result.get(sessionName)?.map((activity) => activity.label)).toEqual([
+      `agent-${liveAgentId}`,
+    ]);
+  });
+});

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts

@@ -25,9 +25,9 @@ export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResol
     }
     const liveIds = new Set<string>();
     for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed.length > 0) {
-        liveIds.add(trimmed);
+      const agentId = line.trim().split(/\s+/)[0];
+      if (agentId.length > 0) {
+        liveIds.add(agentId);
       }
     }
     return liveIds;