github-issue-tower-defence-management 1.114.0 → 1.114.1

package/src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.ts

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { InteractiveLiveSession } from '../../domain/entities/InteractiveLiveSession';
 import { InteractiveLiveSessionTranscriptResolver } from '../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
@@ -12,18 +13,14 @@ const modifiedEpochMs = (filePath: string): number | 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.
- */
+const defaultSharedProjectsDirectory = (): string =>
+  path.join(os.homedir(), '.claude', 'projects');
+
 export class FileSystemInteractiveLiveSessionTranscriptResolver implements InteractiveLiveSessionTranscriptResolver {
+  constructor(
+    private readonly sharedProjectsDirectory: string = defaultSharedProjectsDirectory(),
+  ) {}
+
   resolveTranscriptPaths = (
     sessions: InteractiveLiveSession[],
   ): Map<string, string> => {
@@ -40,36 +37,59 @@ export class FileSystemInteractiveLiveSessionTranscriptResolver implements Inter
   private resolveTranscriptPath = (
     session: InteractiveLiveSession,
   ): string | null => {
-    const projectsDirectory = path.join(session.configDir, 'projects');
+    const projectsDirectories = this.listProjectsDirectories(session.configDir);
+    let latestPath: string | null = null;
+    let latestEpochMs = -Infinity;
+    for (const candidateSessionId of session.candidateSessionIds) {
+      const fileName = `${candidateSessionId}.jsonl`;
+      for (const projectsDirectory of projectsDirectories) {
+        for (const candidate of this.listCandidatePaths(
+          projectsDirectory,
+          fileName,
+        )) {
+          const epochMs = modifiedEpochMs(candidate);
+          if (epochMs === null) {
+            continue;
+          }
+          if (epochMs > latestEpochMs) {
+            latestEpochMs = epochMs;
+            latestPath = candidate;
+          }
+        }
+      }
+    }
+    return latestPath;
+  };
+
+  private listProjectsDirectories = (configDir: string): string[] => {
+    const perSessionProjectsDirectory = path.join(configDir, 'projects');
+    if (perSessionProjectsDirectory === this.sharedProjectsDirectory) {
+      return [perSessionProjectsDirectory];
+    }
+    return [perSessionProjectsDirectory, this.sharedProjectsDirectory];
+  };
+
+  private listCandidatePaths = (
+    projectsDirectory: string,
+    fileName: string,
+  ): string[] => {
     let projectEntries: fs.Dirent[];
     try {
       projectEntries = fs.readdirSync(projectsDirectory, {
         withFileTypes: true,
       });
     } catch {
-      return null;
+      return [];
     }
-    const fileName = `${session.sessionId}.jsonl`;
-    let latestPath: string | null = null;
-    let latestEpochMs = -Infinity;
+    const candidatePaths: string[] = [];
     for (const projectEntry of projectEntries) {
       if (!projectEntry.isDirectory()) {
         continue;
       }
-      const candidate = path.join(
-        projectsDirectory,
-        projectEntry.name,
-        fileName,
+      candidatePaths.push(
+        path.join(projectsDirectory, projectEntry.name, fileName),
       );
-      const epochMs = modifiedEpochMs(candidate);
-      if (epochMs === null) {
-        continue;
-      }
-      if (epochMs > latestEpochMs) {
-        latestEpochMs = epochMs;
-        latestPath = candidate;
-      }
     }
-    return latestPath;
+    return candidatePaths;
   };
 }

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

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionRecordReader } from './FileSystemSessionRecordReader';
+
+describe('FileSystemSessionRecordReader', () => {
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-record-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(configDir, { force: true, recursive: true });
+  });
+
+  const writeRecord = (pid: number, record: object): void => {
+    const sessionsDirectory = path.join(configDir, 'sessions');
+    fs.mkdirSync(sessionsDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(sessionsDirectory, `${pid}.json`),
+      JSON.stringify(record),
+      'utf8',
+    );
+  };
+
+  it('returns the current session id recorded for the pid', () => {
+    writeRecord(201, { pid: 201, sessionId: 'rotated-uuid', status: 'busy' });
+    const reader = new FileSystemSessionRecordReader();
+
+    expect(reader.readCurrentSessionId(configDir, 201)).toBe('rotated-uuid');
+  });
+
+  it('returns null when the session record file is absent', () => {
+    const reader = new FileSystemSessionRecordReader();
+
+    expect(reader.readCurrentSessionId(configDir, 999)).toBeNull();
+  });
+
+  it('returns null when the session record is not valid json', () => {
+    const sessionsDirectory = path.join(configDir, 'sessions');
+    fs.mkdirSync(sessionsDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(sessionsDirectory, '201.json'),
+      'not json',
+      'utf8',
+    );
+    const reader = new FileSystemSessionRecordReader();
+
+    expect(reader.readCurrentSessionId(configDir, 201)).toBeNull();
+  });
+
+  it('returns null when the record has no string session id', () => {
+    writeRecord(201, { pid: 201, sessionId: 42 });
+    const reader = new FileSystemSessionRecordReader();
+
+    expect(reader.readCurrentSessionId(configDir, 201)).toBeNull();
+  });
+});

package/src/adapter/repositories/FileSystemSessionRecordReader.ts

@@ -0,0 +1,31 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SessionRecordReader } from '../../domain/usecases/adapter-interfaces/SessionRecordReader';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+export class FileSystemSessionRecordReader implements SessionRecordReader {
+  readCurrentSessionId = (configDir: string, pid: number): string | null => {
+    const recordPath = path.join(configDir, 'sessions', `${pid}.json`);
+    let content: string;
+    try {
+      content = fs.readFileSync(recordPath, 'utf8');
+    } catch {
+      return null;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return null;
+    }
+    if (!isRecord(parsed)) {
+      return null;
+    }
+    const sessionId = parsed.sessionId;
+    return typeof sessionId === 'string' && sessionId.length > 0
+      ? sessionId
+      : null;
+  };
+}

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

@@ -1,6 +1,7 @@
 import { LocalProcessLiveSessionProcessSnapshotProvider } from './LocalProcessLiveSessionProcessSnapshotProvider';
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import { SessionRecordReader } from '../../domain/usecases/adapter-interfaces/SessionRecordReader';
 
 describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
   const makeRunner = (
@@ -29,6 +30,13 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
     readEnviron: (pid: number) => byPid[pid] ?? null,
   });
 
+  const makeSessionRecordReader = (
+    byPid: Record<number, string>,
+  ): SessionRecordReader => ({
+    readCurrentSessionId: (_configDir: string, 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}': {
@@ -56,9 +64,14 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
         CLAUDE_CONFIG_DIR: '/config/workbench',
       },
     });
+    const sessionRecordReader = makeSessionRecordReader({
+      101: 'issue-rotated-uuid',
+      201: 'wb-rotated-uuid',
+    });
     const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
       runner,
       environReader,
+      sessionRecordReader,
     );
 
     const snapshot = await provider.getSnapshot();
@@ -75,6 +88,7 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
       ppid: 200,
       commandLine: 'claude --name workbench',
       sessionId: 'wb-uuid',
+      currentSessionId: 'wb-rotated-uuid',
       configDir: '/config/workbench',
     });
     expect(snapshot.processes).toContainEqual({
@@ -82,10 +96,44 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
       ppid: 1,
       commandLine: 'shell',
       sessionId: null,
+      currentSessionId: null,
       configDir: null,
     });
   });
 
+  it('leaves currentSessionId null when the session record is absent', 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: '    201     200 claude --name workbench',
+      },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      makeEnvironReader({
+        201: {
+          CLAUDE_CODE_SESSION_ID: 'wb-uuid',
+          CLAUDE_CONFIG_DIR: '/config/workbench',
+        },
+      }),
+      makeSessionRecordReader({}),
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.processes).toEqual([
+      {
+        pid: 201,
+        ppid: 200,
+        commandLine: 'claude --name workbench',
+        sessionId: 'wb-uuid',
+        currentSessionId: null,
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+
   it('returns an empty snapshot when tmux reports no sessions', async () => {
     const runner = makeRunner({
       'tmux list-sessions -F #{session_name}': { stdout: '' },
@@ -94,6 +142,7 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
     const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
       runner,
       makeEnvironReader({}),
+      makeSessionRecordReader({}),
     );
 
     const snapshot = await provider.getSnapshot();
@@ -121,6 +170,7 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
           CLAUDE_CONFIG_DIR: '/config/workbench',
         },
       }),
+      makeSessionRecordReader({ 201: 'wb-rotated-uuid' }),
     );
 
     const snapshot = await provider.getSnapshot();
@@ -131,6 +181,7 @@ describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
         ppid: 200,
         commandLine: 'claude --name workbench',
         sessionId: 'wb-uuid',
+        currentSessionId: 'wb-rotated-uuid',
         configDir: '/config/workbench',
       },
     ]);

package/src/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.ts

@@ -1,11 +1,13 @@
 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 { SessionRecordReader } from '../../domain/usecases/adapter-interfaces/SessionRecordReader';
 import {
   LiveSessionPaneProcess,
   LiveSessionProcessInfo,
   LiveSessionProcessSnapshot,
 } from '../../domain/entities/LiveSessionProcessSnapshot';
+import { FileSystemSessionRecordReader } from './FileSystemSessionRecordReader';
 
 const SESSION_ID_ENV_KEY = 'CLAUDE_CODE_SESSION_ID';
 const CONFIG_DIR_ENV_KEY = 'CLAUDE_CONFIG_DIR';
@@ -21,6 +23,7 @@ export class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessi
   constructor(
     private readonly localCommandRunner: LocalCommandRunner,
     private readonly environReader: ProcessEnvironReader,
+    private readonly sessionRecordReader: SessionRecordReader = new FileSystemSessionRecordReader(),
   ) {}
 
   getSnapshot = async (): Promise<LiveSessionProcessSnapshot> => {
@@ -80,12 +83,18 @@ export class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessi
       const ppid = Number(match[2]);
       const commandLine = match[3].trim();
       const environ = this.environReader.readEnviron(pid);
+      const configDir = environ?.[CONFIG_DIR_ENV_KEY] ?? null;
+      const currentSessionId =
+        configDir === null
+          ? null
+          : this.sessionRecordReader.readCurrentSessionId(configDir, pid);
       processes.push({
         pid,
         ppid,
         commandLine,
         sessionId: environ?.[SESSION_ID_ENV_KEY] ?? null,
-        configDir: environ?.[CONFIG_DIR_ENV_KEY] ?? null,
+        currentSessionId,
+        configDir,
       });
     }
     return processes;

package/src/domain/entities/InteractiveLiveSession.ts

@@ -1,5 +1,6 @@
 export type InteractiveLiveSession = {
   sessionName: string;
   sessionId: string;
+  candidateSessionIds: string[];
   configDir: string;
 };

package/src/domain/entities/LiveSessionProcessSnapshot.ts

@@ -8,6 +8,7 @@ export type LiveSessionProcessInfo = {
   ppid: number;
   commandLine: string;
   sessionId: string | null;
+  currentSessionId: string | null;
   configDir: string | null;
 };
 

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.test.ts

@@ -60,6 +60,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
   const sessionFor = (sessionName: string): InteractiveLiveSession => ({
     sessionName,
     sessionId: `${sessionName}-uuid`,
+    candidateSessionIds: [`${sessionName}-uuid`],
     configDir: `/config/${sessionName}`,
   });
 
@@ -80,6 +81,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ppid: 100 + index * 10,
       commandLine: `claude --name ${sessionName}`,
       sessionId: `${sessionName}-uuid`,
+      currentSessionId: `${sessionName}-uuid`,
       configDir: `/config/${sessionName}`,
     }));
     return { sessions, processes };
@@ -299,6 +301,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           commandLine:
             'claude --verbose -p Take ownership of https://example.com/issues/1 and finish it',
           sessionId: 'aw-uuid',
+          currentSessionId: 'aw-uuid',
           configDir: '/config/aw',
         },
       ],
@@ -407,6 +410,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     expect(sessionFor('workbench')).toEqual({
       sessionName: 'workbench',
       sessionId: 'workbench-uuid',
+      candidateSessionIds: ['workbench-uuid'],
       configDir: '/config/workbench',
     });
   });

package/src/domain/usecases/ResolveInteractiveLiveSessionsUseCase.test.ts

@@ -1,9 +1,22 @@
 import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
-import { LiveSessionProcessSnapshot } from '../entities/LiveSessionProcessSnapshot';
+import {
+  LiveSessionProcessInfo,
+  LiveSessionProcessSnapshot,
+} from '../entities/LiveSessionProcessSnapshot';
 
 describe('ResolveInteractiveLiveSessionsUseCase', () => {
   const useCase = new ResolveInteractiveLiveSessionsUseCase();
 
+  const processInfo = (
+    overrides: Partial<LiveSessionProcessInfo> &
+      Pick<LiveSessionProcessInfo, 'pid' | 'ppid' | 'commandLine'>,
+  ): LiveSessionProcessInfo => ({
+    sessionId: null,
+    currentSessionId: null,
+    configDir: null,
+    ...overrides,
+  });
+
   it('resolves an issue-url-named session through its pane child process', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [
@@ -13,20 +26,14 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
         },
       ],
       processes: [
-        {
-          pid: 100,
-          ppid: 1,
-          commandLine: 'tmux pane shell',
-          sessionId: null,
-          configDir: null,
-        },
-        {
+        processInfo({ pid: 100, ppid: 1, commandLine: 'tmux pane shell' }),
+        processInfo({
           pid: 101,
           ppid: 100,
           commandLine: 'claude --model opus --resume abc',
           sessionId: 'abc',
           configDir: '/config/issues-9',
-        },
+        }),
       ],
     };
 
@@ -36,29 +43,51 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
       {
         sessionName: 'https_//github_com/owner/repo/issues/9',
         sessionId: 'abc',
+        candidateSessionIds: ['abc'],
         configDir: '/config/issues-9',
       },
     ]);
   });
 
-  it('resolves a plain-named session such as workbench', () => {
+  it('puts the rotated current session id before the launch env id', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [{ sessionName: 'workbench', panePids: [200] }],
       processes: [
-        {
-          pid: 200,
-          ppid: 1,
-          commandLine: 'shell',
-          sessionId: null,
-          configDir: null,
-        },
-        {
+        processInfo({
+          pid: 201,
+          ppid: 200,
+          commandLine: 'claude --name workbench',
+          sessionId: 'launch-uuid',
+          currentSessionId: 'rotated-uuid',
+          configDir: '/config/workbench',
+        }),
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        sessionId: 'launch-uuid',
+        candidateSessionIds: ['rotated-uuid', 'launch-uuid'],
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+
+  it('keeps a single candidate id when the current id equals the launch id', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'workbench', panePids: [200] }],
+      processes: [
+        processInfo({
           pid: 201,
           ppid: 200,
           commandLine: 'claude --model opus --name workbench',
           sessionId: 'wb-uuid',
+          currentSessionId: 'wb-uuid',
           configDir: '/config/workbench',
-        },
+        }),
       ],
     };
 
@@ -68,6 +97,7 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
       {
         sessionName: 'workbench',
         sessionId: 'wb-uuid',
+        candidateSessionIds: ['wb-uuid'],
         configDir: '/config/workbench',
       },
     ]);
@@ -77,27 +107,15 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [{ sessionName: 'control-room', panePids: [300] }],
       processes: [
-        {
-          pid: 300,
-          ppid: 1,
-          commandLine: 'shell',
-          sessionId: null,
-          configDir: null,
-        },
-        {
-          pid: 301,
-          ppid: 300,
-          commandLine: 'node wrapper',
-          sessionId: null,
-          configDir: null,
-        },
-        {
+        processInfo({ pid: 300, ppid: 1, commandLine: 'shell' }),
+        processInfo({ pid: 301, ppid: 300, commandLine: 'node wrapper' }),
+        processInfo({
           pid: 302,
           ppid: 301,
           commandLine: 'claude --name control-room',
           sessionId: 'cr-uuid',
           configDir: '/config/control-room',
-        },
+        }),
       ],
     };
 
@@ -107,6 +125,7 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
       {
         sessionName: 'control-room',
         sessionId: 'cr-uuid',
+        candidateSessionIds: ['cr-uuid'],
         configDir: '/config/control-room',
       },
     ]);
@@ -116,21 +135,15 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [{ sessionName: 'aw-host', panePids: [400] }],
       processes: [
-        {
-          pid: 400,
-          ppid: 1,
-          commandLine: 'shell',
-          sessionId: null,
-          configDir: null,
-        },
-        {
+        processInfo({ pid: 400, ppid: 1, commandLine: 'shell' }),
+        processInfo({
           pid: 401,
           ppid: 400,
           commandLine:
             'claude --verbose -p Take ownership of https://example.com/issues/1 and finish it',
           sessionId: 'aw-uuid',
           configDir: '/config/aw',
-        },
+        }),
       ],
     };
 
@@ -143,13 +156,12 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [{ sessionName: 'partial', panePids: [500] }],
       processes: [
-        {
+        processInfo({
           pid: 501,
           ppid: 500,
           commandLine: 'claude --model opus',
-          sessionId: null,
           configDir: '/config/partial',
-        },
+        }),
       ],
     };
 
@@ -162,13 +174,13 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
     const snapshot: LiveSessionProcessSnapshot = {
       sessions: [{ sessionName: 'monitored', panePids: [600] }],
       processes: [
-        {
+        processInfo({
           pid: 601,
           ppid: 600,
           commandLine: 'node monitor.js',
           sessionId: 'mon-uuid',
           configDir: '/config/monitor',
-        },
+        }),
       ],
     };
 
@@ -184,20 +196,14 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
         { sessionName: 'empty', panePids: [800] },
       ],
       processes: [
-        {
+        processInfo({
           pid: 701,
           ppid: 700,
           commandLine: 'claude --name workbench',
           sessionId: 'wb-uuid',
           configDir: '/config/workbench',
-        },
-        {
-          pid: 801,
-          ppid: 800,
-          commandLine: 'bash idle',
-          sessionId: null,
-          configDir: null,
-        },
+        }),
+        processInfo({ pid: 801, ppid: 800, commandLine: 'bash idle' }),
       ],
     };
 
@@ -207,6 +213,7 @@ describe('ResolveInteractiveLiveSessionsUseCase', () => {
       {
         sessionName: 'workbench',
         sessionId: 'wb-uuid',
+        candidateSessionIds: ['wb-uuid'],
         configDir: '/config/workbench',
       },
     ]);

package/src/domain/usecases/ResolveInteractiveLiveSessionsUseCase.ts

@@ -69,12 +69,31 @@ export class ResolveInteractiveLiveSessionsUseCase {
       sessions.push({
         sessionName: session.sessionName,
         sessionId: interactiveProcess.sessionId,
+        candidateSessionIds:
+          this.collectCandidateSessionIds(interactiveProcess),
         configDir: interactiveProcess.configDir,
       });
     }
     return sessions;
   };
 
+  private collectCandidateSessionIds = (
+    interactiveProcess: LiveSessionProcessInfo,
+  ): string[] => {
+    const candidateSessionIds: string[] = [];
+    const seenSessionIds = new Set<string>();
+    for (const sessionId of [
+      interactiveProcess.currentSessionId,
+      interactiveProcess.sessionId,
+    ]) {
+      if (sessionId !== null && !seenSessionIds.has(sessionId)) {
+        seenSessionIds.add(sessionId);
+        candidateSessionIds.push(sessionId);
+      }
+    }
+    return candidateSessionIds;
+  };
+
   private findInteractiveProcess = (
     panePids: number[],
     processByPid: Map<number, LiveSessionProcessInfo>,

package/src/domain/usecases/adapter-interfaces/SessionRecordReader.ts

@@ -0,0 +1,3 @@
+export interface SessionRecordReader {
+  readCurrentSessionId: (configDir: string, pid: number) => string | null;
+}