github-issue-tower-defence-management 1.104.3 → 1.105.0

package/src/adapter/entry-points/console/{consoleServer.ts → webServer.ts}

@@ -27,7 +27,7 @@ import {
 } from './consoleOperationApi';
 import { ImageFetcher, fetchProxiedImage } from './consoleImageProxy';
 
-export const DEFAULT_CONSOLE_PORT = 9981;
+export const DEFAULT_WEB_PORT = 9981;
 
 export const CONSOLE_TOKEN_HEADER = 'x-pv-token';
 
@@ -152,7 +152,7 @@ const readStaticFile = (filePath: string): Buffer | null => {
   }
 };
 
-export type ConsoleServerOptions = {
+export type WebServerOptions = {
   accessToken: string;
   uiDistDir: string;
   consoleDataOutputDir: string | null;
@@ -236,7 +236,7 @@ const serveBootstrapIndex = (response: http.ServerResponse): void => {
 };
 
 const serveIndexHtml = (
-  options: ConsoleServerOptions,
+  options: WebServerOptions,
   response: http.ServerResponse,
 ): void => {
   const indexFilePath = resolveStaticFilePath(options.uiDistDir, '/index.html');
@@ -279,7 +279,7 @@ const sendImage = (
 };
 
 const handleImageProxy = async (
-  options: ConsoleServerOptions,
+  options: WebServerOptions,
   response: http.ServerResponse,
   searchParams: URLSearchParams,
 ): Promise<void> => {
@@ -342,7 +342,7 @@ const parseRequestBody = (raw: string): Record<string, unknown> | null => {
 };
 
 const handleReadApi = async (
-  options: ConsoleServerOptions,
+  options: WebServerOptions,
   requestPath: string,
   searchParams: URLSearchParams,
 ): Promise<{ statusCode: number; body: unknown } | null> => {
@@ -402,7 +402,7 @@ const dispatchOperation = (
 };
 
 const handleOperationApi = async (
-  options: ConsoleServerOptions,
+  options: WebServerOptions,
   requestPath: string,
   body: Record<string, unknown>,
 ): Promise<{ statusCode: number; body: unknown } | null> => {
@@ -432,7 +432,7 @@ const handleOperationApi = async (
 };
 
 const handleTokenedRequest = async (
-  options: ConsoleServerOptions,
+  options: WebServerOptions,
   request: http.IncomingMessage,
   response: http.ServerResponse,
   requestPath: string,
@@ -525,8 +525,8 @@ const handleTokenedRequest = async (
   sendNotFound(response);
 };
 
-export const handleConsoleRequest = async (
-  options: ConsoleServerOptions,
+export const handleWebRequest = async (
+  options: WebServerOptions,
   request: http.IncomingMessage,
   response: http.ServerResponse,
 ): Promise<void> => {
@@ -624,25 +624,23 @@ const sendInternalServerError = (response: http.ServerResponse): void => {
   response.end('Internal Server Error');
 };
 
-export const createConsoleServer = (
-  options: ConsoleServerOptions,
-): http.Server =>
+export const createWebServer = (options: WebServerOptions): http.Server =>
   http.createServer((request, response) => {
-    handleConsoleRequest(options, request, response).catch((error) => {
+    handleWebRequest(options, request, response).catch((error) => {
       console.error('console request failed', error);
       sendInternalServerError(response);
     });
   });
 
-export type StartConsoleServerOptions = ConsoleServerOptions & {
+export type StartWebServerOptions = WebServerOptions & {
   port: number;
 };
 
-export const startConsoleServer = (
-  options: StartConsoleServerOptions,
+export const startWebServer = (
+  options: StartWebServerOptions,
 ): Promise<http.Server> =>
   new Promise((resolve, reject) => {
-    const server = createConsoleServer(options);
+    const server = createWebServer(options);
     server.once('error', reject);
     server.listen(options.port, () => {
       server.removeListener('error', reject);

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

@@ -3,6 +3,9 @@ import TYPIA from 'typia';
 import fs from 'fs';
 import { writeSituationFile } from './situationFileWriter';
 import { writeConsoleLists } from './consoleListsWriter';
+import { writeDashboardRow } from './dashboardRowWriter';
+import { writeMachineStatus } from './machineStatusWriter';
+import { writeTokenStatus } from './tokenStatusWriter';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
 import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
 import { writeRotationOrderFile } from './rotationOrderFileWriter';
@@ -55,6 +58,8 @@ import {
   PREPARATION_STATUS_NAME,
 } from '../../../domain/entities/WorkflowStatus';
 
+const DEFAULT_DASHBOARD_DATA_DIR: string | null = null;
+
 export class HandleScheduledEventUseCaseHandler {
   handle = async (
     configFilePath: string,
@@ -74,6 +79,7 @@ export class HandleScheduledEventUseCaseHandler {
       allowedIssueAuthors?: string | string[] | null;
       claudeCodeOauthTokenListJsonPath?: string;
       consoleDataOutputDir?: string;
+      dashboardDataDir?: string;
       workflowBlockerStoryName?: string;
       inTmuxDataOutputDir?: string;
       inTmuxConsoleBaseUrl?: string;
@@ -416,6 +422,52 @@ export class HandleScheduledEventUseCaseHandler {
         );
       }
 
+      const dashboardDataDir =
+        mergedInput.dashboardDataDir ?? DEFAULT_DASHBOARD_DATA_DIR;
+
+      try {
+        writeDashboardRow({
+          dashboardDataDir,
+          pjcode: input.projectName,
+          assigneeLogin: input.manager,
+          issues: result.issues,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to write dashboard row: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      try {
+        await writeMachineStatus({
+          dashboardDataDir,
+          allIssuesCacheDir: `${cachePath}/allIssues-${result.project.id}`,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to write machine status: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      try {
+        writeTokenStatus({
+          dashboardDataDir,
+          tokenListJsonPath:
+            mergedInput.claudeCodeOauthTokenListJsonPath ?? null,
+          issues: result.issues,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to write token status: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
       const inTmuxNow = new Date();
 
       try {

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

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { DashboardRowFile, writeDashboardRow } from './dashboardRowWriter';
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
+
+const ASSIGNEE = 'HiromiShikata';
+
+let issueCounter = 0;
+const makeIssue = (overrides: Partial<Issue>): Issue => {
+  issueCounter += 1;
+  return {
+    nameWithOwner: 'demo/repo',
+    number: issueCounter,
+    title: `Issue ${issueCounter}`,
+    state: 'OPEN',
+    status: null,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: `https://github.com/demo/repo/issues/${issueCounter}`,
+    assignees: [ASSIGNEE],
+    labels: [],
+    org: 'demo',
+    repo: 'repo',
+    body: '',
+    itemId: `item-${issueCounter}`,
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: new Date('2026-06-13T08:18:45.000Z'),
+    author: 'someone',
+    closingIssueReferenceUrls: [],
+    ...overrides,
+  };
+};
+
+describe('writeDashboardRow', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    issueCounter = 0;
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-row-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('writes a per-project row file with counts, pjcode and capturedAt', () => {
+    writeDashboardRow({
+      dashboardDataDir: dir,
+      pjcode: 'um',
+      assigneeLogin: ASSIGNEE,
+      issues: [
+        makeIssue({ status: 'Unread' }),
+        makeIssue({ status: 'Awaiting Quality Check' }),
+      ],
+      generatedAt: '2026-06-26T12:00:00.000Z',
+    });
+
+    const written = readJson(path.join(dir, 'projects', 'um.json'));
+    const expected: DashboardRowFile = {
+      pjcode: 'um',
+      capturedAt: '2026-06-26T12:00:00.000Z',
+      unread: 1,
+      todo: 0,
+      qc: 1,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    };
+    expect(written).toEqual(expected);
+  });
+
+  it('is a no-op when dashboardDataDir is unset', () => {
+    writeDashboardRow({
+      dashboardDataDir: null,
+      pjcode: 'um',
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue({ status: 'Unread' })],
+    });
+
+    expect(fs.readdirSync(dir)).toEqual([]);
+  });
+
+  it('is a no-op when pjcode or assigneeLogin is missing', () => {
+    writeDashboardRow({
+      dashboardDataDir: dir,
+      pjcode: null,
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue({ status: 'Unread' })],
+    });
+    writeDashboardRow({
+      dashboardDataDir: dir,
+      pjcode: 'um',
+      assigneeLogin: null,
+      issues: [makeIssue({ status: 'Unread' })],
+    });
+
+    expect(fs.readdirSync(dir)).toEqual([]);
+  });
+});

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

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import {
+  DashboardRow,
+  GenerateDashboardRowUseCase,
+} from '../../../domain/usecases/dashboard/GenerateDashboardRowUseCase';
+
+export type DashboardRowWriterParams = {
+  dashboardDataDir: string | null | undefined;
+  pjcode: string | null | undefined;
+  assigneeLogin: string | null | undefined;
+  issues: Issue[];
+  generatedAt?: string;
+};
+
+export type DashboardRowFile = DashboardRow & {
+  pjcode: string;
+  capturedAt: string;
+};
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data));
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const writeDashboardRow = (params: DashboardRowWriterParams): void => {
+  const { dashboardDataDir, pjcode, assigneeLogin, issues } = params;
+  if (!dashboardDataDir || !pjcode || !assigneeLogin) {
+    return;
+  }
+
+  const row: DashboardRow = new GenerateDashboardRowUseCase().run({
+    issues,
+    assigneeLogin,
+  });
+
+  const file: DashboardRowFile = {
+    pjcode,
+    capturedAt: params.generatedAt ?? new Date().toISOString(),
+    ...row,
+  };
+
+  writeJsonAtomic(
+    path.join(dashboardDataDir, 'projects', `${pjcode}.json`),
+    file,
+  );
+};

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

@@ -0,0 +1,100 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { ProcHostMetricsRepository } from '../../repositories/ProcHostMetricsRepository';
+import { MachineStatusFile, writeMachineStatus } from './machineStatusWriter';
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
+
+const buildHostMetricsRepository = (
+  procDirectory: string,
+): {
+  repository: ProcHostMetricsRepository;
+} => {
+  fs.writeFileSync(
+    path.join(procDirectory, 'meminfo'),
+    'MemTotal: 1000 kB\nMemAvailable: 450 kB\n',
+  );
+  fs.writeFileSync(
+    path.join(procDirectory, 'loadavg'),
+    '1.50 0.80 0.40 1/100 200\n',
+  );
+  const statPath = path.join(procDirectory, 'stat');
+  fs.writeFileSync(statPath, 'cpu  600 0 0 400 0 0 0 0 0 0\n');
+  const sleep = async (): Promise<void> => {
+    fs.writeFileSync(statPath, 'cpu  660 0 0 440 0 0 0 0 0 0\n');
+  };
+  return { repository: new ProcHostMetricsRepository(procDirectory, sleep) };
+};
+
+describe('writeMachineStatus', () => {
+  let dir: string;
+  let procDirectory: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'machine-status-'));
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'machine-proc-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  it('writes machine-status.json with mem, cpu, load and cycle minutes', async () => {
+    const { repository } = buildHostMetricsRepository(procDirectory);
+    const cacheDir = path.join(dir, 'allIssues-PVT');
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const newer = path.join(cacheDir, 'a.json');
+    const older = path.join(cacheDir, 'b.json');
+    fs.writeFileSync(older, '[]');
+    fs.writeFileSync(newer, '[]');
+    const base = Date.now();
+    fs.utimesSync(older, new Date(base - 900000), new Date(base - 900000));
+    fs.utimesSync(newer, new Date(base), new Date(base));
+
+    await writeMachineStatus({
+      dashboardDataDir: dir,
+      allIssuesCacheDir: cacheDir,
+      hostMetricsRepository: repository,
+      now: new Date('2026-06-26T12:00:00.000Z'),
+    });
+
+    const written = readJson(path.join(dir, 'machine-status.json'));
+    const expected: MachineStatusFile = {
+      memPct: 55,
+      cpuPct: 60,
+      load: [1.5, 0.8, 0.4],
+      cycleMinutes: 15,
+      capturedAt: '2026-06-26T12:00:00.000Z',
+    };
+    expect(written).toEqual(expected);
+  });
+
+  it('writes cycleMinutes null when fewer than two cache files exist', async () => {
+    const { repository } = buildHostMetricsRepository(procDirectory);
+    const cacheDir = path.join(dir, 'allIssues-PVT');
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.writeFileSync(path.join(cacheDir, 'only.json'), '[]');
+
+    await writeMachineStatus({
+      dashboardDataDir: dir,
+      allIssuesCacheDir: cacheDir,
+      hostMetricsRepository: repository,
+    });
+
+    const written = readJson(path.join(dir, 'machine-status.json'));
+    expect(written).toMatchObject({ cycleMinutes: null });
+  });
+
+  it('is a no-op when dashboardDataDir is unset', async () => {
+    const { repository } = buildHostMetricsRepository(procDirectory);
+    await writeMachineStatus({
+      dashboardDataDir: null,
+      allIssuesCacheDir: null,
+      hostMetricsRepository: repository,
+    });
+    expect(fs.readdirSync(dir)).toEqual([]);
+  });
+});

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

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  ProcHostMetricsRepository,
+  cycleMinutesFromMtimes,
+} from '../../repositories/ProcHostMetricsRepository';
+
+export type MachineStatusWriterParams = {
+  dashboardDataDir: string | null | undefined;
+  allIssuesCacheDir: string | null | undefined;
+  hostMetricsRepository?: ProcHostMetricsRepository;
+  now?: Date;
+};
+
+export type MachineStatusFile = {
+  memPct: number;
+  cpuPct: number;
+  load: [number, number, number];
+  cycleMinutes: number | null;
+  capturedAt: string;
+};
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data));
+  fs.renameSync(tmpPath, filePath);
+};
+
+const cacheFileMtimesDescending = (allIssuesCacheDir: string): number[] => {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(allIssuesCacheDir);
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.endsWith('.json'))
+    .map((entry) => {
+      try {
+        return fs.statSync(path.join(allIssuesCacheDir, entry)).mtimeMs / 1000;
+      } catch {
+        return null;
+      }
+    })
+    .filter((value): value is number => value !== null)
+    .sort((a, b) => b - a);
+};
+
+export const writeMachineStatus = async (
+  params: MachineStatusWriterParams,
+): Promise<void> => {
+  const { dashboardDataDir, allIssuesCacheDir } = params;
+  if (!dashboardDataDir) {
+    return;
+  }
+
+  const hostMetricsRepository =
+    params.hostMetricsRepository ?? new ProcHostMetricsRepository();
+
+  const memPct = hostMetricsRepository.readMemoryUsedPercent();
+  const cpuPct = await hostMetricsRepository.readCpuUsedPercent();
+  const load = hostMetricsRepository.readLoadAverages();
+
+  const cycleMinutes = allIssuesCacheDir
+    ? cycleMinutesFromMtimes(cacheFileMtimesDescending(allIssuesCacheDir))
+    : null;
+
+  const file: MachineStatusFile = {
+    memPct,
+    cpuPct,
+    load: [load.oneMinute, load.fiveMinute, load.fifteenMinute],
+    cycleMinutes,
+    capturedAt: (params.now ?? new Date()).toISOString(),
+  };
+
+  writeJsonAtomic(path.join(dashboardDataDir, 'machine-status.json'), file);
+};

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

@@ -0,0 +1,176 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { ClaudeInteractiveSession } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { TakeOwnershipSpawn } from '../../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+import { RateLimitSnapshot } from '../../proxy/RateLimitCache';
+import { TokenStatusFile, writeTokenStatus } from './tokenStatusWriter';
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
+
+const ASSIGNEE = 'HiromiShikata';
+
+const baseSnapshot = (
+  overrides: Partial<RateLimitSnapshot> = {},
+): RateLimitSnapshot => ({
+  fiveHourUtilization: 0.1,
+  fiveHourReset: 0,
+  sevenDayUtilization: 0.1,
+  sevenDayReset: 0,
+  blocked: false,
+  rejected: false,
+  unifiedRejected: false,
+  fiveHourRejected: false,
+  sevenDayRejected: false,
+  unifiedStatus: 'allowed',
+  overageDisabledReason: null,
+  modelWeeklyLimits: {},
+  lastUpdatedEpoch: 0,
+  blockedUntilEpoch: 0,
+  ...overrides,
+});
+
+const makeIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue',
+  state: 'OPEN',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-13T08:18:45.000Z'),
+  author: 'someone',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+describe('writeTokenStatus', () => {
+  let dir: string;
+  let tokenListPath: string;
+  const now = new Date('2026-06-26T12:00:00.000Z');
+  const nowEpoch = Math.floor(now.getTime() / 1000);
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-status-'));
+    tokenListPath = path.join(dir, 'tokens.json');
+    fs.writeFileSync(
+      tokenListPath,
+      JSON.stringify([
+        { name: 'alice', token: 'token-a' },
+        { name: 'bob', token: 'token-b' },
+      ]),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('writes token-status.json with per-token color, util, prep and hum', () => {
+    const interactiveSessions: ClaudeInteractiveSession[] = [
+      {
+        token: 'token-a',
+        sessionId: 'session-1',
+        issueUrl: 'https://github.com/demo/repo/issues/1',
+      },
+    ];
+    const spawns: TakeOwnershipSpawn[] = [
+      { token: 'token-a', logPath: '/logs-aw/x.log' },
+      { token: 'token-a', logPath: '/logs-aw/x.log' },
+      { token: 'token-a', logPath: '/logs-aw/y.log' },
+    ];
+
+    writeTokenStatus({
+      dashboardDataDir: dir,
+      tokenListJsonPath: tokenListPath,
+      issues: [
+        makeIssue({
+          status: 'In Tmux by human',
+          url: 'https://github.com/demo/repo/issues/1',
+        }),
+      ],
+      now,
+      readSnapshot: (token) =>
+        token === 'token-a'
+          ? baseSnapshot({
+              fiveHourUtilization: 0.42,
+              fiveHourReset: nowEpoch + 3600,
+              sevenDayUtilization: 0.5,
+              sevenDayReset: nowEpoch + 86400,
+            })
+          : null,
+      interactiveSessionRepository: {
+        listInteractiveSessions: () => interactiveSessions,
+      },
+      spawnRepository: { listSpawns: () => spawns },
+    });
+
+    const written = readJson(path.join(dir, 'token-status.json'));
+    const expected: TokenStatusFile = {
+      capturedAt: '2026-06-26T12:00:00.000Z',
+      tokens: [
+        {
+          name: 'alice',
+          fiveHourUtilizationPercent: 42,
+          fiveHourResetSeconds: 3600,
+          sevenDayUtilizationPercent: 50,
+          sevenDayResetSeconds: 86400,
+          color: 'G',
+          prep: 2,
+          hum: 1,
+        },
+        {
+          name: 'bob',
+          fiveHourUtilizationPercent: null,
+          fiveHourResetSeconds: null,
+          sevenDayUtilizationPercent: null,
+          sevenDayResetSeconds: null,
+          color: 'Y',
+          prep: 0,
+          hum: 0,
+        },
+      ],
+    };
+    expect(written).toEqual(expected);
+  });
+
+  it('is a no-op when dashboardDataDir is unset', () => {
+    writeTokenStatus({
+      dashboardDataDir: null,
+      tokenListJsonPath: tokenListPath,
+      issues: [],
+      readSnapshot: () => null,
+      interactiveSessionRepository: { listInteractiveSessions: () => [] },
+      spawnRepository: { listSpawns: () => [] },
+    });
+    expect(fs.existsSync(path.join(dir, 'token-status.json'))).toBe(false);
+  });
+
+  it('is a no-op when the token list path is unset', () => {
+    writeTokenStatus({
+      dashboardDataDir: dir,
+      tokenListJsonPath: null,
+      issues: [],
+      readSnapshot: () => null,
+      interactiveSessionRepository: { listInteractiveSessions: () => [] },
+      spawnRepository: { listSpawns: () => [] },
+    });
+    expect(fs.existsSync(path.join(dir, 'token-status.json'))).toBe(false);
+  });
+});