github-issue-tower-defence-management 1.133.0 → 1.135.0

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

@@ -86,6 +86,7 @@ export class HandleScheduledEventUseCaseHandler {
   handle = async (
     configFilePath: string,
     _verbose: boolean,
+    inTmuxProjectOrderOverride: string[] | null = null,
   ): Promise<{
     project: Project;
     issues: Issue[];
@@ -103,6 +104,7 @@ export class HandleScheduledEventUseCaseHandler {
       claudeCodeOauthTokenListJsonPath?: string;
       consoleDataOutputDir?: string;
       dashboardDataDir?: string;
+      disks?: { title: string; mountpoint: string }[];
       workflowBlockerStoryName?: string;
       inTmuxDataOutputDir?: string;
       newIssueRepo?: string;
@@ -492,6 +494,7 @@ export class HandleScheduledEventUseCaseHandler {
         await writeMachineStatus({
           dashboardDataDir,
           allIssuesCacheDir: `${cachePath}/allIssues-${result.project.id}`,
+          disks: mergedInput.disks ?? null,
         });
       } catch (error) {
         console.error(
@@ -524,7 +527,10 @@ export class HandleScheduledEventUseCaseHandler {
           inTmuxDataOutputDir: mergedInput.inTmuxDataOutputDir ?? null,
           inTmuxConsoleBaseUrl: mergedInput.inTmuxConsoleBaseUrl ?? null,
           inTmuxConsoleToken: mergedInput.inTmuxConsoleToken ?? null,
-          inTmuxProjectOrder: mergedInput.inTmuxProjectOrder ?? null,
+          inTmuxProjectOrder:
+            inTmuxProjectOrderOverride ??
+            mergedInput.inTmuxProjectOrder ??
+            null,
           pjcode: input.projectName,
           assigneeLogin: input.manager,
           org: input.org,

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

@@ -91,6 +91,67 @@ describe('writeMachineStatus', () => {
     expect(written).toEqual(expected);
   });
 
+  it('writes a per-mountpoint disks array when a disks list is configured', async () => {
+    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');
+    };
+    const blocksByMountpoint: Record<
+      string,
+      { blocks: number; bfree: number; bavail: number }
+    > = {
+      '/': { blocks: 1100, bfree: 200, bavail: 100 },
+      '/mountpoint-secondary': { blocks: 1000, bfree: 700, bavail: 700 },
+    };
+    const repository = new ProcHostMetricsRepository(
+      procDirectory,
+      sleep,
+      (mountpoint) => blocksByMountpoint[mountpoint],
+    );
+
+    await writeMachineStatus({
+      dashboardDataDir: dir,
+      allIssuesCacheDir: null,
+      disks: [
+        { title: 'D', mountpoint: '/' },
+        { title: 'S', mountpoint: '/mountpoint-secondary' },
+      ],
+      hostMetricsRepository: repository,
+      now: new Date('2026-06-26T12:00:00.000Z'),
+    });
+
+    const written = readJson(path.join(dir, 'machine-status.json'));
+    expect(written).toMatchObject({
+      diskPct: 90,
+      disks: [
+        { title: 'D', pct: 90 },
+        { title: 'S', pct: 30 },
+      ],
+    });
+  });
+
+  it('omits the disks array when no disks list is configured', async () => {
+    const { repository } = buildHostMetricsRepository(procDirectory);
+    await writeMachineStatus({
+      dashboardDataDir: dir,
+      allIssuesCacheDir: null,
+      hostMetricsRepository: repository,
+      now: new Date('2026-06-26T12:00:00.000Z'),
+    });
+    const written = readJson(path.join(dir, 'machine-status.json'));
+    expect(written).toMatchObject({ diskPct: 90 });
+    expect(written).not.toHaveProperty('disks');
+  });
+
   it('writes cycleMinutes null when there is no previous machine-status', async () => {
     const { repository } = buildHostMetricsRepository(procDirectory);
     const cacheDir = path.join(dir, 'allIssues-PVT');

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

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { DiskConfig } from '../cli/projectConfig';
 import {
   ProcHostMetricsRepository,
   cycleMinutesFromFetchTimestamps,
@@ -8,14 +9,21 @@ import {
 export type MachineStatusWriterParams = {
   dashboardDataDir: string | null | undefined;
   allIssuesCacheDir: string | null | undefined;
+  disks?: DiskConfig[] | null;
   hostMetricsRepository?: ProcHostMetricsRepository;
   now?: Date;
 };
 
+export type MachineStatusDisk = {
+  title: string;
+  pct: number;
+};
+
 export type MachineStatusFile = {
   memPct: number;
   cpuPct: number;
   diskPct: number;
+  disks?: MachineStatusDisk[];
   load: [number, number, number];
   cycleMinutes: number | null;
   lastFetchedAt: string | null;
@@ -68,6 +76,14 @@ export const writeMachineStatus = async (
   const diskPct = hostMetricsRepository.readDiskUsedPercent();
   const load = hostMetricsRepository.readLoadAverages();
 
+  const configuredDisks = params.disks ?? [];
+  const disks: MachineStatusDisk[] = configuredDisks.map((disk) => ({
+    title: disk.title,
+    pct: hostMetricsRepository.readDiskUsedPercentForMountpoint(
+      disk.mountpoint,
+    ),
+  }));
+
   const machineStatusPath = path.join(dashboardDataDir, 'machine-status.json');
   const previousLastFetchedAt =
     readLastFetchedAtFromJsonFile(machineStatusPath);
@@ -83,6 +99,7 @@ export const writeMachineStatus = async (
     memPct,
     cpuPct,
     diskPct,
+    ...(disks.length > 0 ? { disks } : {}),
     load: [load.oneMinute, load.fiveMinute, load.fifteenMinute],
     cycleMinutes,
     lastFetchedAt: currentLastFetchedAt,

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

@@ -167,6 +167,31 @@ describe('ProcHostMetricsRepository', () => {
     expect(repository.readDiskUsedPercent()).toBe(90);
   });
 
+  it('reads the df-style disk used percent for a given mountpoint', () => {
+    const blocksByMountpoint: Record<string, DiskBlocks> = {
+      '/': { blocks: 1100, bfree: 200, bavail: 100 },
+      '/mountpoint-a': { blocks: 1000, bfree: 700, bavail: 700 },
+    };
+    const requestedMountpoints: string[] = [];
+    const repository = new ProcHostMetricsRepository(
+      procDirectory,
+      async () => {},
+      (mountpoint) => {
+        requestedMountpoints.push(mountpoint);
+        const blocks = blocksByMountpoint[mountpoint];
+        if (!blocks) {
+          throw new Error(`unexpected mountpoint ${mountpoint}`);
+        }
+        return blocks;
+      },
+    );
+    expect(repository.readDiskUsedPercentForMountpoint('/mountpoint-a')).toBe(
+      30,
+    );
+    expect(repository.readDiskUsedPercentForMountpoint('/')).toBe(90);
+    expect(requestedMountpoints).toEqual(['/mountpoint-a', '/']);
+  });
+
   it('samples /proc/stat twice and computes the busy percent', async () => {
     const statPath = path.join(procDirectory, 'stat');
     let sampleIndex = 0;

package/src/adapter/repositories/ProcHostMetricsRepository.ts

@@ -173,4 +173,9 @@ export class ProcHostMetricsRepository {
     const { blocks, bfree, bavail } = this.readDiskBlocks(this.rootPath);
     return parseDiskUsedPercent(blocks, bfree, bavail);
   };
+
+  readDiskUsedPercentForMountpoint = (mountpoint: string): number => {
+    const { blocks, bfree, bavail } = this.readDiskBlocks(mountpoint);
+    return parseDiskUsedPercent(blocks, bfree, bavail);
+  };
 }

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

@@ -2107,7 +2107,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     fetchSpy: FetchSpy,
     predicate: (url: string, body: string) => boolean,
   ): number =>
-    fetchSpy.mock.calls.filter(([input, init]) =>
+    fetchSpy.mock.calls.filter(([input, init]: Parameters<typeof fetch>) =>
       predicate(requestUrlOf(input), requestBodyOf(init)),
     ).length;
 
@@ -2287,6 +2287,28 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       expect(result?.isCiStateSuccess).toBe(true);
       expect(result?.isPassedAllCiJob).toBe(true);
     });
+
+    it('returns isCiStateSuccess true when check run conclusions are neutral or skipped', async () => {
+      mockFetchRoutes({
+        slimPullRequest: () => buildSlimPullRequestResponse(),
+        checkRuns: () => ({
+          total_count: 2,
+          check_runs: [
+            { id: 100, name: 'lint', conclusion: 'neutral' },
+            { id: 200, name: 'docs', conclusion: 'skipped' },
+          ],
+        }),
+      });
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.getOpenPullRequest(
+        'https://github.com/HiromiShikata/test-repository/pull/31',
+      );
+
+      expect(result).not.toBeNull();
+      expect(result?.isCiStateSuccess).toBe(true);
+      expect(result?.isPassedAllCiJob).toBe(true);
+    });
   });
 
   describe('getOpenPullRequest required check resolution via REST', () => {
@@ -2625,13 +2647,14 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         ),
       ).toBe(2);
       const secondSlimCall = fetchSpy.mock.calls
-        .map(([input, init]) =>
+        .map(([input, init]): GraphqlRequestBody | null =>
           requestUrlOf(input) === 'https://api.github.com/graphql'
             ? parseGraphqlRequestBody(init)
             : null,
         )
         .filter(
-          (body) => body !== null && body.query.includes('headRefOid'),
+          (body): body is GraphqlRequestBody =>
+            body !== null && body.query.includes('headRefOid'),
         )[1];
       expect(secondSlimCall?.variables.reviewThreadsAfter).toBe('cursor-1');
     });

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -398,6 +398,7 @@ ${JSON.stringify(e)}
     });
     await this.revertNotReadyReviewQueueIssueUseCase.run({
       projectUrl: input.projectUrl,
+      manager: input.manager,
       labelsAsLlmAgentName,
       changeTargetPathAliases: input.changeTargetPathAliases,
       allowedIssueAuthors,