github-issue-tower-defence-management 1.106.0 → 1.108.0

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

@@ -181,6 +181,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     const address = server.address();
@@ -198,6 +200,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -224,6 +228,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -254,6 +260,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -286,6 +294,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -315,6 +325,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -338,6 +350,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -364,6 +378,8 @@ describe('webServer integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -502,6 +518,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: dataDir,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -539,6 +557,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       issueRepository,
       issueTitleStateCache: new IssueTitleStateCache(),
       port: 0,
@@ -573,6 +593,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       issueRepository,
       resolveProject: async (pjcode) =>
         pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
@@ -622,6 +644,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: dataDir,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       issueRepository,
       resolveProject: async (pjcode) =>
         pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
@@ -668,6 +692,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       issueRepository,
       resolveProject: async (pjcode) =>
         pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
@@ -704,6 +730,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       issueRepository,
       resolveProject: async (pjcode) =>
         pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
@@ -755,6 +783,8 @@ describe('webServer new routes integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -809,6 +839,23 @@ describe('resolveFlatInTmuxFilePath', () => {
   });
 });
 
+describe('resolveDashboardFilePath', () => {
+  const baseDir = path.join(os.tmpdir(), 'dashboard-static');
+
+  it('resolves /tdpm.txt under the dashboard dir', () => {
+    expect(resolveDashboardFilePath(baseDir, '/tdpm.txt')).toBe(
+      path.join(path.resolve(baseDir), 'tdpm.txt'),
+    );
+  });
+
+  it('returns null for any other path', () => {
+    expect(resolveDashboardFilePath(baseDir, '/tdpm.html')).toBeNull();
+    expect(resolveDashboardFilePath(baseDir, '/other.txt')).toBeNull();
+    expect(resolveDashboardFilePath(baseDir, '/')).toBeNull();
+    expect(resolveDashboardFilePath(baseDir, '/sub/tdpm.txt')).toBeNull();
+  });
+});
+
 describe('webServer flat in-tmux-by-human route integration', () => {
   const testToken = 'integration-test-token-value';
 
@@ -884,6 +931,8 @@ describe('webServer flat in-tmux-by-human route integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     return { server, tmpDir, inTmuxDataDir };
@@ -998,6 +1047,8 @@ describe('webServer flat in-tmux-by-human route integration', () => {
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
       dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectCodes: [],
       port: 0,
     });
     try {
@@ -1013,23 +1064,6 @@ describe('webServer flat in-tmux-by-human route integration', () => {
   });
 });
 
-describe('resolveDashboardFilePath', () => {
-  const baseDir = path.join(os.tmpdir(), 'dashboard-data');
-
-  it('resolves /tdpm.txt under the dashboard dir', () => {
-    expect(resolveDashboardFilePath(baseDir, '/tdpm.txt')).toBe(
-      path.join(path.resolve(baseDir), 'tdpm.txt'),
-    );
-  });
-
-  it('returns null for any other path', () => {
-    expect(resolveDashboardFilePath(baseDir, '/tdpm.html')).toBeNull();
-    expect(resolveDashboardFilePath(baseDir, '/other.txt')).toBeNull();
-    expect(resolveDashboardFilePath(baseDir, '/')).toBeNull();
-    expect(resolveDashboardFilePath(baseDir, '/sub/tdpm.txt')).toBeNull();
-  });
-});
-
 describe('webServer dashboard /tdpm.txt route integration', () => {
   const testToken = 'integration-test-token-value';
 
@@ -1084,54 +1118,219 @@ describe('webServer dashboard /tdpm.txt route integration', () => {
       });
     });
 
-  const dashboardRaw =
-    '<tt>MEM&nbsp;30%</tt><br>\n<tt>pj&nbsp;unr&nbsp;tdo</tt><br>\n';
+  const writeDataFiles = (dataDir: string): void => {
+    fs.mkdirSync(path.join(dataDir, 'projects'), { recursive: true });
+    fs.writeFileSync(
+      path.join(dataDir, 'projects', 'um.json'),
+      JSON.stringify({
+        pjcode: 'um',
+        capturedAt: '2026-06-26T00:00:00.000Z',
+        unread: 3,
+        todo: 1,
+        qc: 2,
+        fail: 0,
+        pr: 0,
+        ws: 4,
+        dep: 1,
+        blocker: 0,
+      }),
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'projects', 'xc.json'),
+      JSON.stringify({
+        pjcode: 'xc',
+        capturedAt: '2026-06-26T00:00:00.000Z',
+        unread: 0,
+        todo: 0,
+        qc: 0,
+        fail: 0,
+        pr: 0,
+        ws: 2,
+        dep: 0,
+        blocker: 0,
+      }),
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'machine-status.json'),
+      JSON.stringify({
+        memPct: 55,
+        cpuPct: 62,
+        diskPct: 89,
+        load: [16, 23, 40],
+        cycleMinutes: 14,
+        capturedAt: '2026-06-26T00:00:00.000Z',
+      }),
+    );
+    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: '2026-06-26T00:00:00.000Z',
+      }),
+    );
+  };
 
-  const startWithDashboard = async (): Promise<{
-    server: http.Server;
-    tmpDir: string;
-  }> => {
+  const expectedComposed =
+    '<tt>M55%&nbsp;C62%&nbsp;D89%&nbsp;cy14</tt><br>\n' +
+    '<tt>LA&nbsp;16&nbsp;23&nbsp;40</tt><br>\n' +
+    '<tt>pj&nbsp;&nbsp;&nbsp;unr&nbsp;tdo&nbsp;aqc&nbsp;fal&nbsp;prp&nbsp;aws&nbsp;dep</tt><br>\n' +
+    '<tt>🟢um&nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;2&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;4&nbsp;&nbsp;&nbsp;1</tt><br>\n' +
+    '<tt>🟢xc&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;2&nbsp;&nbsp;&nbsp;0</tt><br>\n' +
+    '<tt></tt><br>\n' +
+    '<tt>🟢alice&nbsp;&nbsp;10%&nbsp;0d01h00&nbsp;&nbsp;12%&nbsp;5d00h00&nbsp;2&nbsp;1</tt><br>\n';
+
+  const staticDashboardRaw =
+    '<tt>STATIC&nbsp;DASHBOARD</tt><br>\n<tt>pj&nbsp;unr&nbsp;tdo</tt><br>\n';
+
+  const writeStaticDashboard = (staticDir: string): void => {
+    fs.writeFileSync(path.join(staticDir, 'tdpm.txt'), staticDashboardRaw);
+  };
+
+  const startServer = async (overrides: {
+    dashboardDir: string | null;
+    dashboardDataDir: string | null;
+  }): Promise<{ server: http.Server; tmpDir: string }> => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
-    fs.writeFileSync(path.join(tmpDir, 'tdpm.txt'), dashboardRaw);
-    fs.writeFileSync(path.join(tmpDir, 'secret.txt'), 'secret content');
     const server = await startWebServer({
       accessToken: testToken,
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: null,
       inTmuxDataDir: null,
-      dashboardDir: tmpDir,
+      dashboardDir: overrides.dashboardDir,
+      dashboardDataDir: overrides.dashboardDataDir,
+      dashboardProjectCodes: ['um', 'xc'],
       port: 0,
     });
     return { server, tmpDir };
   };
 
-  it('serves /tdpm.txt without a token, byte-identical, as text/html with an explicit Content-Length and no chunked encoding', async () => {
-    const { server, tmpDir } = await startWithDashboard();
+  it('composes /tdpm.txt from the data files when dashboardDataDir is set and every file is present', async () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-data-'));
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    writeDataFiles(dataDir);
+    writeStaticDashboard(staticDir);
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: dataDir,
+    });
     try {
       const response = await requestServer(server, '/tdpm.txt');
       expect(response.statusCode).toBe(200);
-      expect(response.body).toBe(dashboardRaw);
+      expect(response.body).toBe(expectedComposed);
       expect(response.contentType).toBe('text/html; charset=utf-8');
       expect(response.contentLength).toBe(
-        String(Buffer.byteLength(dashboardRaw)),
+        String(Buffer.byteLength(expectedComposed)),
       );
       expect(response.transferEncoding).toBeUndefined();
       expect(response.cacheControl).toBe('no-store');
     } finally {
       await closeServer(server);
       fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(dataDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
     }
   });
 
-  it('returns 404 for /tdpm.txt when the file is absent', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
-    const server = await startWebServer({
-      accessToken: testToken,
-      uiDistDir: path.join(tmpDir, 'ui-dist'),
-      consoleDataOutputDir: null,
-      inTmuxDataDir: null,
-      dashboardDir: tmpDir,
-      port: 0,
+  it('serves the static tdpm.txt unchanged when dashboardDataDir is unset', async () => {
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    writeStaticDashboard(staticDir);
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: null,
+    });
+    try {
+      const response = await requestServer(server, '/tdpm.txt');
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toBe(staticDashboardRaw);
+      expect(response.contentType).toBe('text/html; charset=utf-8');
+      expect(response.contentLength).toBe(
+        String(Buffer.byteLength(staticDashboardRaw)),
+      );
+      expect(response.cacheControl).toBe('no-store');
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to the static tdpm.txt when dashboardDataDir is set but the data files are absent', async () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-data-'));
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    writeStaticDashboard(staticDir);
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: dataDir,
+    });
+    try {
+      const response = await requestServer(server, '/tdpm.txt');
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toBe(staticDashboardRaw);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(dataDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to the static tdpm.txt when only some data files are present', async () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-data-'));
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'machine-status.json'),
+      JSON.stringify({
+        memPct: 55,
+        cpuPct: 62,
+        diskPct: 89,
+        load: [16, 23, 40],
+        cycleMinutes: 14,
+        capturedAt: '2026-06-26T00:00:00.000Z',
+      }),
+    );
+    writeStaticDashboard(staticDir);
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: dataDir,
+    });
+    try {
+      const response = await requestServer(server, '/tdpm.txt');
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toBe(staticDashboardRaw);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(dataDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns 404 for /tdpm.txt when the static file is absent and compose mode is inactive', async () => {
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: null,
     });
     try {
       const response = await requestServer(server, '/tdpm.txt');
@@ -1139,23 +1338,15 @@ describe('webServer dashboard /tdpm.txt route integration', () => {
     } finally {
       await closeServer(server);
       fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
     }
   });
 
-  it('returns 404 for /tdpm.txt when dashboardDir is null', async () => {
-    const { server, tmpDir } = await (async () => {
-      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
-      fs.writeFileSync(path.join(dir, 'tdpm.txt'), dashboardRaw);
-      const srv = await startWebServer({
-        accessToken: testToken,
-        uiDistDir: path.join(dir, 'ui-dist'),
-        consoleDataOutputDir: null,
-        inTmuxDataDir: null,
-        dashboardDir: null,
-        port: 0,
-      });
-      return { server: srv, tmpDir: dir };
-    })();
+  it('returns 404 for /tdpm.txt when both dashboardDir and dashboardDataDir are null', async () => {
+    const { server, tmpDir } = await startServer({
+      dashboardDir: null,
+      dashboardDataDir: null,
+    });
     try {
       const response = await requestServer(server, '/tdpm.txt');
       expect(response.statusCode).toBe(404);
@@ -1166,13 +1357,24 @@ describe('webServer dashboard /tdpm.txt route integration', () => {
   });
 
   it('rejects a non-GET method on /tdpm.txt with 404', async () => {
-    const { server, tmpDir } = await startWithDashboard();
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-data-'));
+    const staticDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'dashboard-static-'),
+    );
+    writeDataFiles(dataDir);
+    writeStaticDashboard(staticDir);
+    const { server, tmpDir } = await startServer({
+      dashboardDir: staticDir,
+      dashboardDataDir: dataDir,
+    });
     try {
       const response = await requestServer(server, '/tdpm.txt', 'POST');
       expect(response.statusCode).toBe(404);
     } finally {
       await closeServer(server);
       fs.rmSync(tmpDir, { recursive: true, force: true });
+      fs.rmSync(dataDir, { recursive: true, force: true });
+      fs.rmSync(staticDir, { recursive: true, force: true });
     }
   });
 });
@@ -1250,6 +1452,8 @@ describe('webServer image proxy', () => {
         consoleDataOutputDir: null,
         inTmuxDataDir: null,
         dashboardDir: null,
+        dashboardDataDir: null,
+        dashboardProjectCodes: [],
         githubToken: token,
         imageFetcher: fetcher,
         port: 0,

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

@@ -26,9 +26,15 @@ import {
   handleTriage,
 } from './consoleOperationApi';
 import { ImageFetcher, fetchProxiedImage } from './consoleImageProxy';
+import {
+  composeDashboardText,
+  dashboardComposeFilesPresent,
+} from './dashboardComposeService';
 
 export const DEFAULT_WEB_PORT = 9981;
 
+export const DEFAULT_DASHBOARD_PROJECT_CODES = ['um', 'xm', 'xc', 'ut'];
+
 export const CONSOLE_TOKEN_HEADER = 'x-pv-token';
 
 const PLACEHOLDER_INDEX_HTML = `<!DOCTYPE html>
@@ -158,6 +164,8 @@ export type WebServerOptions = {
   consoleDataOutputDir: string | null;
   inTmuxDataDir: string | null;
   dashboardDir: string | null;
+  dashboardDataDir: string | null;
+  dashboardProjectCodes: string[];
   githubToken?: string | null;
   imageFetcher?: ImageFetcher | null;
   issueRepository?: IssueRepository | null;
@@ -525,6 +533,40 @@ const handleTokenedRequest = async (
   sendNotFound(response);
 };
 
+const readStaticDashboardContent = (
+  dashboardDir: string | null,
+  requestPath: string,
+): Buffer | null => {
+  if (dashboardDir === null) {
+    return null;
+  }
+  const dashboardFilePath = resolveDashboardFilePath(dashboardDir, requestPath);
+  if (dashboardFilePath === null) {
+    return null;
+  }
+  return readStaticFile(dashboardFilePath);
+};
+
+export const resolveDashboardContent = (
+  options: WebServerOptions,
+  requestPath: string,
+): Buffer | null => {
+  if (
+    options.dashboardDataDir !== null &&
+    dashboardComposeFilesPresent({
+      dashboardDataDir: options.dashboardDataDir,
+      projectCodes: options.dashboardProjectCodes,
+    })
+  ) {
+    const dashboardText = composeDashboardText({
+      dashboardDataDir: options.dashboardDataDir,
+      projectCodes: options.dashboardProjectCodes,
+    });
+    return Buffer.from(dashboardText, 'utf-8');
+  }
+  return readStaticDashboardContent(options.dashboardDir, requestPath);
+};
+
 export const handleWebRequest = async (
   options: WebServerOptions,
   request: http.IncomingMessage,
@@ -544,16 +586,7 @@ export const handleWebRequest = async (
       sendNotFound(response);
       return;
     }
-    if (options.dashboardDir === null) {
-      sendNotFound(response);
-      return;
-    }
-    const dashboardFilePath = resolveDashboardFilePath(
-      options.dashboardDir,
-      requestPath,
-    );
-    const dashboardContent =
-      dashboardFilePath === null ? null : readStaticFile(dashboardFilePath);
+    const dashboardContent = resolveDashboardContent(options, requestPath);
     if (dashboardContent === null) {
       sendNotFound(response);
       return;

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

@@ -25,7 +25,18 @@ const buildHostMetricsRepository = (
   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) };
+  const readDiskBlocks = (): {
+    blocks: number;
+    bfree: number;
+    bavail: number;
+  } => ({ blocks: 1100, bfree: 200, bavail: 100 });
+  return {
+    repository: new ProcHostMetricsRepository(
+      procDirectory,
+      sleep,
+      readDiskBlocks,
+    ),
+  };
 };
 
 describe('writeMachineStatus', () => {
@@ -42,7 +53,7 @@ describe('writeMachineStatus', () => {
     fs.rmSync(procDirectory, { recursive: true, force: true });
   });
 
-  it('writes machine-status.json with mem, cpu, load and cycle minutes', async () => {
+  it('writes machine-status.json with mem, cpu, disk, load and cycle minutes', async () => {
     const { repository } = buildHostMetricsRepository(procDirectory);
     const cacheDir = path.join(dir, 'allIssues-PVT');
     fs.mkdirSync(cacheDir, { recursive: true });
@@ -65,6 +76,7 @@ describe('writeMachineStatus', () => {
     const expected: MachineStatusFile = {
       memPct: 55,
       cpuPct: 60,
+      diskPct: 90,
       load: [1.5, 0.8, 0.4],
       cycleMinutes: 15,
       capturedAt: '2026-06-26T12:00:00.000Z',

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

@@ -15,6 +15,7 @@ export type MachineStatusWriterParams = {
 export type MachineStatusFile = {
   memPct: number;
   cpuPct: number;
+  diskPct: number;
   load: [number, number, number];
   cycleMinutes: number | null;
   capturedAt: string;
@@ -61,6 +62,7 @@ export const writeMachineStatus = async (
 
   const memPct = hostMetricsRepository.readMemoryUsedPercent();
   const cpuPct = await hostMetricsRepository.readCpuUsedPercent();
+  const diskPct = hostMetricsRepository.readDiskUsedPercent();
   const load = hostMetricsRepository.readLoadAverages();
 
   const cycleMinutes = allIssuesCacheDir
@@ -70,6 +72,7 @@ export const writeMachineStatus = async (
   const file: MachineStatusFile = {
     memPct,
     cpuPct,
+    diskPct,
     load: [load.oneMinute, load.fiveMinute, load.fifteenMinute],
     cycleMinutes,
     capturedAt: (params.now ?? new Date()).toISOString(),

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

@@ -2,10 +2,12 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import {
+  DiskBlocks,
   ProcHostMetricsRepository,
   cpuUsedPercentFromSamples,
   cycleMinutesFromMtimes,
   parseCpuSample,
+  parseDiskUsedPercent,
   parseLoadAverages,
   parseMemoryUsedPercent,
 } from './ProcHostMetricsRepository';
@@ -72,6 +74,20 @@ describe('parseLoadAverages', () => {
   });
 });
 
+describe('parseDiskUsedPercent', () => {
+  it('excludes root-reserved blocks from the denominator like df', () => {
+    expect(parseDiskUsedPercent(1100, 200, 100)).toBe(90);
+  });
+
+  it('matches df when there is no root reservation (bfree equals bavail)', () => {
+    expect(parseDiskUsedPercent(1000, 100, 100)).toBe(90);
+  });
+
+  it('throws when the disk total is not positive', () => {
+    expect(() => parseDiskUsedPercent(100, 200, 0)).toThrow();
+  });
+});
+
 describe('cycleMinutesFromMtimes', () => {
   it('rounds the gap between the two newest generations to whole minutes', () => {
     expect(cycleMinutesFromMtimes([1782469254.0, 1782468443.0])).toBe(14);
@@ -120,6 +136,16 @@ describe('ProcHostMetricsRepository', () => {
     });
   });
 
+  it('reads the df-style disk used percent from the root filesystem statfs', () => {
+    const diskBlocks: DiskBlocks = { blocks: 1100, bfree: 200, bavail: 100 };
+    const repository = new ProcHostMetricsRepository(
+      procDirectory,
+      async () => {},
+      () => diskBlocks,
+    );
+    expect(repository.readDiskUsedPercent()).toBe(90);
+  });
+
   it('samples /proc/stat twice and computes the busy percent', async () => {
     const statPath = path.join(procDirectory, 'stat');
     let sampleIndex = 0;