github-issue-tower-defence-management 1.110.1 → 1.111.0

package/src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.ts

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { InteractiveLiveSession } from '../../domain/entities/InteractiveLiveSession';
+import { InteractiveLiveSessionTranscriptResolver } from '../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+
+const modifiedEpochMs = (filePath: string): number | null => {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.isFile() ? stats.mtimeMs : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Resolves the real transcript path of an interactive Claude Code session from
+ * the session id and config directory taken from the session's process
+ * environment. The transcript lives at
+ * `<configDir>/projects/<cwd-slug>/<sessionId>.jsonl`; this resolver scans the
+ * `projects` subdirectories for a file named `<sessionId>.jsonl` and returns the
+ * most recently modified match. Because resolution is keyed on the process
+ * session id rather than on a session name or issue URL, a plain-named session
+ * (for example one named `workbench`) resolves just as well as an issue-url
+ * named one.
+ */
+export class FileSystemInteractiveLiveSessionTranscriptResolver implements InteractiveLiveSessionTranscriptResolver {
+  resolveTranscriptPaths = (
+    sessions: InteractiveLiveSession[],
+  ): Map<string, string> => {
+    const resolved = new Map<string, string>();
+    for (const session of sessions) {
+      const transcriptPath = this.resolveTranscriptPath(session);
+      if (transcriptPath !== null) {
+        resolved.set(session.sessionName, transcriptPath);
+      }
+    }
+    return resolved;
+  };
+
+  private resolveTranscriptPath = (
+    session: InteractiveLiveSession,
+  ): string | null => {
+    const projectsDirectory = path.join(session.configDir, 'projects');
+    let projectEntries: fs.Dirent[];
+    try {
+      projectEntries = fs.readdirSync(projectsDirectory, {
+        withFileTypes: true,
+      });
+    } catch {
+      return null;
+    }
+    const fileName = `${session.sessionId}.jsonl`;
+    let latestPath: string | null = null;
+    let latestEpochMs = -Infinity;
+    for (const projectEntry of projectEntries) {
+      if (!projectEntry.isDirectory()) {
+        continue;
+      }
+      const candidate = path.join(
+        projectsDirectory,
+        projectEntry.name,
+        fileName,
+      );
+      const epochMs = modifiedEpochMs(candidate);
+      if (epochMs === null) {
+        continue;
+      }
+      if (epochMs > latestEpochMs) {
+        latestEpochMs = epochMs;
+        latestPath = candidate;
+      }
+    }
+    return latestPath;
+  };
+}

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

@@ -16,76 +16,114 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     fs.rmSync(rootDirectory, { force: true, recursive: true });
   });
 
-  const writeOutputFileWithMtime = (
-    sessionName: string,
-    epochSeconds: number,
-  ): void => {
-    const fileName = sessionName.replace(/\//g, '_');
+  const assistantEntry = (timestamp: string): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'progress update' }],
+    },
+  });
+
+  const userEntry = (timestamp: string): object => ({
+    type: 'user',
+    timestamp,
+    message: { role: 'user', content: 'go ahead' },
+  });
+
+  const writeTranscript = (fileName: string, lines: object[]): string => {
     const filePath = path.join(rootDirectory, fileName);
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    fs.utimesSync(filePath, epochSeconds, epochSeconds);
+    fs.writeFileSync(
+      filePath,
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+    return filePath;
   };
 
-  it('returns the latest output epoch derived from each session output file mtime', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeOutputFileWithMtime(sessionName, 1700000000);
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
+  it('returns the latest assistant entry timestamp as the last output epoch', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T10:30:00.000Z'),
+      assistantEntry('2026-06-27T10:05:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
 
-    const result = await repository.listSessionOutputActivities([sessionName]);
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([
-      { sessionName, lastOutputEpochSeconds: 1700000000 },
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
+        ),
+      },
     ]);
   });
 
-  it('omits sessions that have no output file', async () => {
-    const presentSessionName = 'https_//github_com/owner/repo/issues/9';
-    const missingSessionName = 'https_//github_com/owner/repo/issues/10';
-    writeOutputFileWithMtime(presentSessionName, 1700000000);
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
-
-    const result = await repository.listSessionOutputActivities([
-      presentSessionName,
-      missingSessionName,
+  it('ignores user entries when computing the last output epoch', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T11:00:00.000Z'),
     ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([
-      { sessionName: presentSessionName, lastOutputEpochSeconds: 1700000000 },
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
     ]);
   });
 
-  it('returns an empty list when the root directory does not exist', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(
-      path.join(rootDirectory, 'does-not-exist'),
+  it('omits sessions whose transcript file is missing', async () => {
+    const presentPath = writeTranscript('present.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([
+        ['present', presentPath],
+        ['missing', path.join(rootDirectory, 'missing.jsonl')],
+      ]),
     );
 
-    const result = await repository.listSessionOutputActivities([
-      'https_//github_com/owner/repo/issues/9',
+    expect(result).toEqual([
+      {
+        sessionName: 'present',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
     ]);
-
-    expect(result).toEqual([]);
   });
 
-  it('returns an empty list when the root directory is null', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(null);
-
-    const result = await repository.listSessionOutputActivities([
-      'https_//github_com/owner/repo/issues/9',
+  it('omits sessions whose transcript has no assistant entry', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      userEntry('2026-06-27T10:00:00.000Z'),
     ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([]);
   });
 
-  it('returns an empty list when no session names are requested', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
+  it('returns an empty list when no sessions are requested', async () => {
+    const repository = new FileSystemSessionOutputActivityRepository();
 
-    const result = await repository.listSessionOutputActivities([]);
+    const result = await repository.listSessionOutputActivities(new Map());
 
     expect(result).toEqual([]);
   });

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -1,21 +1,41 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { LiveSessionOutputActivity } from '../../domain/entities/LiveSessionOutputActivity';
 import { SessionOutputActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionOutputActivityRepository';
 
-export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
-  constructor(private readonly rootDirectory: string | null) {}
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const readString = (
+  value: Record<string, unknown>,
+  key: string,
+): string | null => {
+  const candidate = value[key];
+  return typeof candidate === 'string' ? candidate : null;
+};
 
+const parseEpochMilliseconds = (timestamp: string | null): number | null => {
+  if (timestamp === null) {
+    return null;
+  }
+  const parsed = Date.parse(timestamp);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+/**
+ * Reads the last main-session output time for each live session from its
+ * already-resolved transcript path. Idle time is computed from the timestamp of
+ * the latest `assistant` entry rather than from the transcript file modification
+ * time, so a transcript touched only by tool results or owner replies still
+ * counts as silent.
+ */
+export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
-    if (this.rootDirectory === null) {
-      return [];
-    }
     const activities: LiveSessionOutputActivity[] = [];
-    for (const sessionName of sessionNames) {
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
       const lastOutputEpochSeconds =
-        this.readLastOutputEpochSeconds(sessionName);
+        this.readLastAssistantOutputEpochSeconds(transcriptPath);
       if (lastOutputEpochSeconds !== null) {
         activities.push({ sessionName, lastOutputEpochSeconds });
       }
@@ -23,26 +43,44 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     return activities;
   };
 
-  private readLastOutputEpochSeconds = (sessionName: string): number | null => {
-    if (this.rootDirectory === null) {
-      return null;
-    }
-    const filePath = path.join(
-      this.rootDirectory,
-      this.toOutputFileName(sessionName),
-    );
-    let stats: fs.Stats;
+  private readLastAssistantOutputEpochSeconds = (
+    transcriptPath: string,
+  ): number | null => {
+    let content: string;
     try {
-      stats = fs.statSync(filePath);
+      content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
       return null;
     }
-    if (!stats.isFile()) {
+    let lastAssistantEpochMs: number | null = null;
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      if (readString(parsed, 'type') !== 'assistant') {
+        continue;
+      }
+      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
+      if (epochMs === null) {
+        continue;
+      }
+      if (lastAssistantEpochMs === null || epochMs > lastAssistantEpochMs) {
+        lastAssistantEpochMs = epochMs;
+      }
+    }
+    if (lastAssistantEpochMs === null) {
       return null;
     }
-    return Math.floor(stats.mtimeMs / 1000);
+    return Math.floor(lastAssistantEpochMs / 1000);
   };
-
-  private toOutputFileName = (sessionName: string): string =>
-    sessionName.replace(/\//g, '_');
 }

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

@@ -0,0 +1,138 @@
+import { LocalProcessLiveSessionProcessSnapshotProvider } from './LocalProcessLiveSessionProcessSnapshotProvider';
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+
+describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
+  const makeRunner = (
+    handlers: Record<
+      string,
+      { stdout: string; stderr?: string; exitCode?: number }
+    >,
+  ): LocalCommandRunner => ({
+    runCommand: jest.fn(async (program: string, args: string[]) => {
+      const key = `${program} ${args.join(' ')}`;
+      const handler = handlers[key];
+      if (handler === undefined) {
+        return { stdout: '', stderr: '', exitCode: 1 };
+      }
+      return {
+        stdout: handler.stdout,
+        stderr: handler.stderr ?? '',
+        exitCode: handler.exitCode ?? 0,
+      };
+    }),
+  });
+
+  const makeEnvironReader = (
+    byPid: Record<number, Record<string, string>>,
+  ): ProcessEnvironReader => ({
+    readEnviron: (pid: number) => byPid[pid] ?? null,
+  });
+
+  it('builds a snapshot of sessions, pane pids, and processes with environment', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': {
+        stdout: 'workbench\nhttps_//github_com/owner/repo/issues/9\n',
+      },
+      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
+      'tmux list-panes -t https_//github_com/owner/repo/issues/9 -F #{pane_pid}':
+        { stdout: '100\n' },
+      'ps -eo pid=,ppid=,args=': {
+        stdout: [
+          '    100       1 shell',
+          '    101     100 claude --name issues-9',
+          '    200       1 shell',
+          '    201     200 claude --name workbench',
+        ].join('\n'),
+      },
+    });
+    const environReader = makeEnvironReader({
+      101: {
+        CLAUDE_CODE_SESSION_ID: 'issue-uuid',
+        CLAUDE_CONFIG_DIR: '/config/issues-9',
+      },
+      201: {
+        CLAUDE_CODE_SESSION_ID: 'wb-uuid',
+        CLAUDE_CONFIG_DIR: '/config/workbench',
+      },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      environReader,
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.sessions).toEqual([
+      { sessionName: 'workbench', panePids: [200] },
+      {
+        sessionName: 'https_//github_com/owner/repo/issues/9',
+        panePids: [100],
+      },
+    ]);
+    expect(snapshot.processes).toContainEqual({
+      pid: 201,
+      ppid: 200,
+      commandLine: 'claude --name workbench',
+      sessionId: 'wb-uuid',
+      configDir: '/config/workbench',
+    });
+    expect(snapshot.processes).toContainEqual({
+      pid: 100,
+      ppid: 1,
+      commandLine: 'shell',
+      sessionId: null,
+      configDir: null,
+    });
+  });
+
+  it('returns an empty snapshot when tmux reports no sessions', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': { stdout: '' },
+      'ps -eo pid=,ppid=,args=': { stdout: '' },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      makeEnvironReader({}),
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.sessions).toEqual([]);
+    expect(snapshot.processes).toEqual([]);
+  });
+
+  it('skips malformed ps lines', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': { stdout: 'workbench\n' },
+      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
+      'ps -eo pid=,ppid=,args=': {
+        stdout: [
+          'garbage line',
+          '    201     200 claude --name workbench',
+        ].join('\n'),
+      },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      makeEnvironReader({
+        201: {
+          CLAUDE_CODE_SESSION_ID: 'wb-uuid',
+          CLAUDE_CONFIG_DIR: '/config/workbench',
+        },
+      }),
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.processes).toEqual([
+      {
+        pid: 201,
+        ppid: 200,
+        commandLine: 'claude --name workbench',
+        sessionId: 'wb-uuid',
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+});

package/src/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.ts

@@ -0,0 +1,93 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { LiveSessionProcessSnapshotProvider } from '../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import {
+  LiveSessionPaneProcess,
+  LiveSessionProcessInfo,
+  LiveSessionProcessSnapshot,
+} from '../../domain/entities/LiveSessionProcessSnapshot';
+
+const SESSION_ID_ENV_KEY = 'CLAUDE_CODE_SESSION_ID';
+const CONFIG_DIR_ENV_KEY = 'CLAUDE_CONFIG_DIR';
+
+/**
+ * Builds a live-session process snapshot from the local host: it lists the live
+ * tmux sessions and each session's pane process ids, lists the full process
+ * tree with command lines, and reads each process environment to expose the
+ * Claude Code session id and config directory. The snapshot is consumed by a
+ * pure resolver, so all host access is contained in this adapter.
+ */
+export class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessionProcessSnapshotProvider {
+  constructor(
+    private readonly localCommandRunner: LocalCommandRunner,
+    private readonly environReader: ProcessEnvironReader,
+  ) {}
+
+  getSnapshot = async (): Promise<LiveSessionProcessSnapshot> => {
+    const sessionNames = await this.listSessionNames();
+    const sessions: LiveSessionPaneProcess[] = [];
+    for (const sessionName of sessionNames) {
+      const panePids = await this.listPanePids(sessionName);
+      sessions.push({ sessionName, panePids });
+    }
+    const processes = await this.listProcesses();
+    return { sessions, processes };
+  };
+
+  private listSessionNames = async (): Promise<string[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['list-sessions', '-F', '#{session_name}'],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    return stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+  };
+
+  private listPanePids = async (sessionName: string): Promise<number[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['list-panes', '-t', sessionName, '-F', '#{pane_pid}'],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    return stdout
+      .split('\n')
+      .map((line) => Number(line.trim()))
+      .filter((pid) => Number.isInteger(pid) && pid > 0);
+  };
+
+  private listProcesses = async (): Promise<LiveSessionProcessInfo[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'ps',
+      ['-eo', 'pid=,ppid=,args='],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    const processes: LiveSessionProcessInfo[] = [];
+    for (const line of stdout.split('\n')) {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+      if (match === null) {
+        continue;
+      }
+      const pid = Number(match[1]);
+      const ppid = Number(match[2]);
+      const commandLine = match[3].trim();
+      const environ = this.environReader.readEnviron(pid);
+      processes.push({
+        pid,
+        ppid,
+        commandLine,
+        sessionId: environ?.[SESSION_ID_ENV_KEY] ?? null,
+        configDir: environ?.[CONFIG_DIR_ENV_KEY] ?? null,
+      });
+    }
+    return processes;
+  };
+}

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

@@ -3,10 +3,12 @@ import { NoUnansweredOwnerCallStatusProvider } from './NoUnansweredOwnerCallStat
 describe('NoUnansweredOwnerCallStatusProvider', () => {
   it('always reports no session as having an unanswered owner call', async () => {
     const provider = new NoUnansweredOwnerCallStatusProvider();
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'session-a',
-      'session-b',
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([
+        ['session-a', '/transcripts/a.jsonl'],
+        ['session-b', '/transcripts/b.jsonl'],
+      ]),
+    );
     expect(result.size).toBe(0);
   });
 });

package/src/adapter/repositories/NoUnansweredOwnerCallStatusProvider.ts

@@ -2,7 +2,7 @@ import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interface
 
 export class NoUnansweredOwnerCallStatusProvider implements OwnerCallStatusProvider {
   listSessionNamesWithUnansweredOwnerCall = (
-    _sessionNames: string[],
+    _transcriptPathBySessionName: Map<string, string>,
   ): Promise<Set<string>> => {
     return Promise.resolve(new Set<string>());
   };

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

@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcFsProcessEnvironReader } from './ProcFsProcessEnvironReader';
+
+describe('ProcFsProcessEnvironReader', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'proc-environ-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { force: true, recursive: true });
+  });
+
+  const writeEnviron = (pid: number, entries: string[]): void => {
+    const pidDirectory = path.join(procDirectory, String(pid));
+    fs.mkdirSync(pidDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(pidDirectory, 'environ'),
+      entries.join('\0') + '\0',
+      'utf8',
+    );
+  };
+
+  it('parses NUL-separated KEY=value pairs from procfs', () => {
+    writeEnviron(123, [
+      'PATH=/usr/bin',
+      'CLAUDE_CODE_SESSION_ID=abc-123',
+      'CLAUDE_CONFIG_DIR=/config/workbench',
+    ]);
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(123);
+
+    expect(result).toEqual({
+      PATH: '/usr/bin',
+      CLAUDE_CODE_SESSION_ID: 'abc-123',
+      CLAUDE_CONFIG_DIR: '/config/workbench',
+    });
+  });
+
+  it('keeps values that themselves contain an equals sign', () => {
+    writeEnviron(124, ['QUERY=a=b=c']);
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(124);
+
+    expect(result).toEqual({ QUERY: 'a=b=c' });
+  });
+
+  it('returns null when the process environ cannot be read', () => {
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(999);
+
+    expect(result).toBeNull();
+  });
+});