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

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

@@ -1,11 +1,8 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { Issue } from '../../../domain/entities/Issue';
-import { Project } from '../../../domain/entities/Project';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
 import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { SilentSessionMessageTemplates } from '../../repositories/ConfigurableSilentSessionMessageComposer';
@@ -16,8 +13,10 @@ import {
 
 const NOW = new Date('2026-06-26T00:00:00.000Z');
 const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
-const ALLOW_CACHE_MINUTES = 10;
-const SESSION_NAME = 'https_//github_com/demo/repo/issues/1';
+const SESSION_NAME = 'workbench';
+const SESSION_ID = 'wb-uuid';
+const PANE_PID = 200;
+const CLAUDE_PID = 201;
 
 const EMPTY_TEMPLATES: SilentSessionMessageTemplates = {
   mainStalledMessage: null,
@@ -25,52 +24,6 @@ const EMPTY_TEMPLATES: SilentSessionMessageTemplates = {
   subAgentMessageFooter: null,
 };
 
-const makeProject = (): Project => ({
-  id: 'project-1',
-  url: 'https://github.com/users/user/projects/1',
-  databaseId: 1,
-  name: 'Test Project',
-  status: {
-    name: 'Status',
-    fieldId: 'field-1',
-    statuses: [],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-});
-
-const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
-  nameWithOwner: 'demo/repo',
-  number: 1,
-  title: 'Issue 1',
-  state: 'OPEN',
-  status: IN_TMUX_STATUS_NAME,
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: 'https://github.com/demo/repo/issues/1',
-  assignees: [],
-  labels: [],
-  org: 'demo',
-  repo: 'repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date(),
-  author: '',
-  closingIssueReferenceUrls: [],
-  ...overrides,
-});
-
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const createMockRunner = (): Mocked<LocalCommandRunner> => ({
@@ -81,34 +34,46 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   }),
 });
 
-const createMockIssueRepository = (
-  issues: Issue[],
-): Pick<IssueRepository, 'getAllOpened'> => ({
-  getAllOpened: jest.fn().mockResolvedValue(issues),
-});
-
 describe('notifySilentTmuxSessions', () => {
-  let outputDirectory: string;
+  let configDir: string;
   let cacheDirectory: string;
 
   beforeEach(() => {
     jest.spyOn(console, 'log').mockImplementation(() => undefined);
-    outputDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-output-'));
+    configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-config-'));
     cacheDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-cache-'));
   });
 
   afterEach(() => {
     jest.restoreAllMocks();
-    fs.rmSync(outputDirectory, { force: true, recursive: true });
+    fs.rmSync(configDir, { force: true, recursive: true });
     fs.rmSync(cacheDirectory, { force: true, recursive: true });
   });
 
-  const writeSilentOutputFile = (sessionName: string): void => {
-    const fileName = sessionName.replace(/\//g, '_');
-    const filePath = path.join(outputDirectory, fileName);
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    const silentEpoch = NOW_EPOCH_SECONDS - 11 * 60;
-    fs.utimesSync(filePath, silentEpoch, silentEpoch);
+  const writeTranscript = (lines: object[]): void => {
+    const projectDirectory = path.join(configDir, 'projects', '-home-user');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, `${SESSION_ID}.jsonl`),
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+  };
+
+  const silentAssistantTranscript = (): void => {
+    const silentTimestamp = new Date(
+      (NOW_EPOCH_SECONDS - 11 * 60) * 1000,
+    ).toISOString();
+    writeTranscript([
+      {
+        type: 'assistant',
+        timestamp: silentTimestamp,
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'progress update' }],
+        },
+      },
+    ]);
   };
 
   const makeCacheRepository = (): LocalStorageCacheRepository =>
@@ -117,16 +82,44 @@ describe('notifySilentTmuxSessions', () => {
       cacheDirectory,
     );
 
+  const makeEnvironReader = (): ProcessEnvironReader => ({
+    readEnviron: (pid: number) =>
+      pid === CLAUDE_PID
+        ? {
+            CLAUDE_CODE_SESSION_ID: SESSION_ID,
+            CLAUDE_CONFIG_DIR: configDir,
+          }
+        : null,
+  });
+
+  const liveSessionRunner = (): Mocked<LocalCommandRunner> => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return { stdout: `${SESSION_NAME}\n`, stderr: '', exitCode: 0 };
+      }
+      if (program === 'tmux' && args[0] === 'list-panes') {
+        return { stdout: `${PANE_PID}\n`, stderr: '', exitCode: 0 };
+      }
+      if (program === 'ps') {
+        return {
+          stdout: `  ${PANE_PID}       1 shell\n  ${CLAUDE_PID}     ${PANE_PID} claude --name ${SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+    return runner;
+  };
+
   const baseParams = (
     runner: LocalCommandRunner,
   ): Parameters<typeof notifySilentTmuxSessions>[0] => ({
-    project: makeProject(),
-    allowCacheMinutes: ALLOW_CACHE_MINUTES,
-    issueRepository: createMockIssueRepository([makeIssue()]),
+    enabled: true,
     localCommandRunner: runner,
+    processEnvironReader: makeEnvironReader(),
     cacheRepository: makeCacheRepository(),
-    sessionOutputRootDirectory: outputDirectory,
-    sessionTranscriptRootDirectory: null,
     ownerCallMarker: null,
     subAgentOutputRootDirectory: null,
     subAgentProcessMatchPattern: null,
@@ -136,20 +129,9 @@ describe('notifySilentTmuxSessions', () => {
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
   });
 
-  const listSessionsRunner = (): Mocked<LocalCommandRunner> => {
-    const runner = createMockRunner();
-    runner.runCommand.mockImplementation(async (program, args) => {
-      if (program === 'tmux' && args[0] === 'list-sessions') {
-        return { stdout: `${SESSION_NAME}\n`, stderr: '', exitCode: 0 };
-      }
-      return { stdout: '', stderr: '', exitCode: 0 };
-    });
-    return runner;
-  };
-
-  it('sends a main stalled notification to a silent monitored live session', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = listSessionsRunner();
+  it('sends a main stalled notification to a silent plain-named live session', async () => {
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions(baseParams(runner));
 
@@ -160,52 +142,21 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall?.[1][4]).toContain('You have produced no output for');
   });
 
-  it('does nothing when neither output root nor sub-agent pattern is configured', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = createMockRunner();
+  it('does nothing when the step is not enabled', async () => {
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentProcessMatchPattern: null,
+      enabled: false,
     });
 
     expect(runner.runCommand.mock.calls).toHaveLength(0);
   });
 
-  it('sends a sub-agent notification driven by the process match pattern even when the main session is not silent', async () => {
-    const runner = createMockRunner();
-    runner.runCommand.mockImplementation(async (program, args) => {
-      if (program === 'tmux' && args[0] === 'list-sessions') {
-        return { stdout: `${SESSION_NAME}\n`, stderr: '', exitCode: 0 };
-      }
-      if (program === 'ps') {
-        return {
-          stdout: `  1200 worker session=${SESSION_NAME} label=task-a\n`,
-          stderr: '',
-          exitCode: 0,
-        };
-      }
-      return { stdout: '', stderr: '', exitCode: 0 };
-    });
-
-    await notifySilentTmuxSessions({
-      ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentProcessMatchPattern:
-        'session=(?<session>[^ ]+) label=(?<label>[^ ]+)',
-    });
-
-    const sendCall = runner.runCommand.mock.calls.find(
-      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
-    );
-    expect(sendCall?.[1][2]).toBe(SESSION_NAME);
-    expect(sendCall?.[1][4]).toContain('task-a');
-  });
-
   it('uses the configured main stalled message template when provided', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = listSessionsRunner();
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
@@ -223,41 +174,28 @@ describe('notifySilentTmuxSessions', () => {
   });
 
   it('suppresses the main stalled notification when the transcript shows an unanswered owner call', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const transcriptDirectory = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'silent-transcript-'),
-    );
-    const transcriptPath = path.join(
-      transcriptDirectory,
-      `${SESSION_NAME.replace(/\//g, '_')}.jsonl`,
-    );
-    fs.writeFileSync(
-      transcriptPath,
-      [
-        JSON.stringify({
-          type: 'user',
-          timestamp: '2026-06-25T23:00:00.000Z',
-          message: { role: 'user', content: 'go ahead' },
-        }),
-        JSON.stringify({
-          type: 'assistant',
-          timestamp: '2026-06-25T23:50:00.000Z',
-          message: {
-            role: 'assistant',
-            stop_reason: 'end_turn',
-            content: [
-              { type: 'text', text: 'waiting <<OWNER_CALL>> please decide' },
-            ],
-          },
-        }),
-      ].join('\n'),
-      'utf8',
-    );
-    const runner = listSessionsRunner();
+    writeTranscript([
+      {
+        type: 'user',
+        timestamp: '2026-06-25T23:00:00.000Z',
+        message: { role: 'user', content: 'go ahead' },
+      },
+      {
+        type: 'assistant',
+        timestamp: '2026-06-25T23:50:00.000Z',
+        message: {
+          role: 'assistant',
+          stop_reason: 'end_turn',
+          content: [
+            { type: 'text', text: 'waiting <<OWNER_CALL>> please decide' },
+          ],
+        },
+      },
+    ]);
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
-      sessionTranscriptRootDirectory: transcriptDirectory,
       ownerCallMarker: '<<OWNER_CALL>>',
     });
 
@@ -265,65 +203,19 @@ describe('notifySilentTmuxSessions', () => {
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
     expect(sendCall).toBeUndefined();
-    fs.rmSync(transcriptDirectory, { force: true, recursive: true });
-  });
-
-  it('sends a sub-agent notification driven by a running transcript even when the main session is not silent', async () => {
-    const transcriptRoot = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'silent-subagent-tx-'),
-    );
-    const subAgentsDir = path.join(
-      transcriptRoot,
-      SESSION_NAME.replace(/\//g, '_'),
-      'subagents',
-    );
-    fs.mkdirSync(subAgentsDir, { recursive: true });
-    const agentPath = path.join(subAgentsDir, 'agent-running1.jsonl');
-    fs.writeFileSync(
-      agentPath,
-      [
-        JSON.stringify({
-          type: 'user',
-          timestamp: '2026-06-25T23:30:00.000Z',
-          message: { role: 'user' },
-        }),
-        JSON.stringify({
-          type: 'assistant',
-          timestamp: '2026-06-25T23:40:00.000Z',
-          message: { role: 'assistant', stop_reason: 'tool_use' },
-        }),
-      ].join('\n'),
-      'utf8',
-    );
-    const silentEpoch = NOW_EPOCH_SECONDS - 6 * 60;
-    fs.utimesSync(agentPath, silentEpoch, silentEpoch);
-    const runner = listSessionsRunner();
-
-    await notifySilentTmuxSessions({
-      ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentTranscriptRootDirectory: transcriptRoot,
-    });
-
-    const sendCall = runner.runCommand.mock.calls.find(
-      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
-    );
-    expect(sendCall?.[1][2]).toBe(SESSION_NAME);
-    expect(sendCall?.[1][4]).toContain('agent-running1');
-    fs.rmSync(transcriptRoot, { force: true, recursive: true });
   });
 
   it('does not re-notify the same silent session on the next cycle within cooldown', async () => {
-    writeSilentOutputFile(SESSION_NAME);
+    silentAssistantTranscript();
     const cacheRepository = makeCacheRepository();
-    const firstRunner = listSessionsRunner();
+    const firstRunner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(firstRunner),
       cacheRepository,
     });
 
-    const secondRunner = listSessionsRunner();
+    const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
       ...baseParams(secondRunner),
       cacheRepository,

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

@@ -1,11 +1,9 @@
-import { Project } from '../../../domain/entities/Project';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { SessionSubAgentActivityRepository } from '../../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
 import { OwnerCallStatusProvider } from '../../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import {
   NotifySilentLiveSessionsUseCase,
-  DEFAULT_MONITORED_STATUS,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
@@ -13,7 +11,9 @@ import {
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
 } from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
 import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
-import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
+import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
 import { FileSystemSessionOutputActivityRepository } from '../../repositories/FileSystemSessionOutputActivityRepository';
 import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
@@ -31,13 +31,10 @@ import {
 import { RealSleeper } from '../../repositories/RealSleeper';
 
 export type NotifySilentTmuxSessionsParams = {
-  project: Project;
-  allowCacheMinutes: number;
-  issueRepository: Pick<IssueRepository, 'getAllOpened'>;
+  enabled: boolean;
   localCommandRunner: LocalCommandRunner;
+  processEnvironReader?: ProcessEnvironReader;
   cacheRepository: Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>;
-  sessionOutputRootDirectory: string | null;
-  sessionTranscriptRootDirectory: string | null;
   ownerCallMarker: string | null;
   subAgentOutputRootDirectory: string | null;
   subAgentProcessMatchPattern: string | null;
@@ -52,18 +49,10 @@ export type NotifySilentTmuxSessionsParams = {
 };
 
 const createOwnerCallStatusProvider = (
-  sessionTranscriptRootDirectory: string | null,
   ownerCallMarker: string | null,
 ): OwnerCallStatusProvider => {
-  if (
-    sessionTranscriptRootDirectory !== null &&
-    ownerCallMarker !== null &&
-    ownerCallMarker.length > 0
-  ) {
-    return new TranscriptOwnerCallStatusProvider(
-      sessionTranscriptRootDirectory,
-      ownerCallMarker,
-    );
+  if (ownerCallMarker !== null && ownerCallMarker.length > 0) {
+    return new TranscriptOwnerCallStatusProvider(ownerCallMarker);
   }
   return new NoUnansweredOwnerCallStatusProvider();
 };
@@ -97,13 +86,10 @@ export const notifySilentTmuxSessions = async (
   params: NotifySilentTmuxSessionsParams,
 ): Promise<void> => {
   const {
-    project,
-    allowCacheMinutes,
-    issueRepository,
+    enabled,
     localCommandRunner,
+    processEnvironReader,
     cacheRepository,
-    sessionOutputRootDirectory,
-    sessionTranscriptRootDirectory,
     ownerCallMarker,
     subAgentOutputRootDirectory,
     subAgentProcessMatchPattern,
@@ -116,13 +102,9 @@ export const notifySilentTmuxSessions = async (
     messageTemplates,
     now,
   } = params;
-  if (
-    sessionOutputRootDirectory === null &&
-    subAgentProcessMatchPattern === null &&
-    subAgentTranscriptRootDirectory === null
-  ) {
+  if (!enabled) {
     console.log(
-      'Silent live session notification skipped: no session output root directory, sub-agent process match pattern, or sub-agent transcript root directory is configured.',
+      'Silent live session notification skipped: not enabled (set silentNotificationEnabled or TDPM_SILENT_NOTIFICATION_ENABLED=true to enable).',
     );
     return;
   }
@@ -131,9 +113,12 @@ export const notifySilentTmuxSessions = async (
     new DefaultSilentSessionMessageComposer(),
   );
   const useCase = new NotifySilentLiveSessionsUseCase(
-    issueRepository,
-    new NodeTmuxSessionRepository(localCommandRunner),
-    new FileSystemSessionOutputActivityRepository(sessionOutputRootDirectory),
+    new LocalProcessLiveSessionProcessSnapshotProvider(
+      localCommandRunner,
+      processEnvironReader ?? new ProcFsProcessEnvironReader(),
+    ),
+    new FileSystemInteractiveLiveSessionTranscriptResolver(),
+    new FileSystemSessionOutputActivityRepository(),
     createSubAgentActivityRepository(
       subAgentTranscriptRootDirectory,
       subAgentProcessMatchPattern,
@@ -141,10 +126,7 @@ export const notifySilentTmuxSessions = async (
       localCommandRunner,
       now,
     ),
-    createOwnerCallStatusProvider(
-      sessionTranscriptRootDirectory,
-      ownerCallMarker,
-    ),
+    createOwnerCallStatusProvider(ownerCallMarker),
     new TmuxSilentSessionNotificationRepository(
       localCommandRunner,
       cacheRepository,
@@ -153,9 +135,6 @@ export const notifySilentTmuxSessions = async (
     new RealSleeper(),
   );
   await useCase.run({
-    project,
-    allowCacheMinutes,
-    monitoredStatus: DEFAULT_MONITORED_STATUS,
     mainSilentThresholdSeconds,
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,

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

@@ -0,0 +1,147 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from './FileSystemInteractiveLiveSessionTranscriptResolver';
+
+describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
+  let configRoot: string;
+
+  beforeEach(() => {
+    configRoot = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'interactive-transcript-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(configRoot, { force: true, recursive: true });
+  });
+
+  const writeTranscript = (params: {
+    configDir: string;
+    cwdSlug: string;
+    sessionId: string;
+    mtimeEpochSeconds?: number;
+  }): string => {
+    const projectDirectory = path.join(
+      params.configDir,
+      'projects',
+      params.cwdSlug,
+    );
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    const filePath = path.join(projectDirectory, `${params.sessionId}.jsonl`);
+    fs.writeFileSync(filePath, '{"type":"custom-title"}', 'utf8');
+    if (params.mtimeEpochSeconds !== undefined) {
+      fs.utimesSync(
+        filePath,
+        params.mtimeEpochSeconds,
+        params.mtimeEpochSeconds,
+      );
+    }
+    return filePath;
+  };
+
+  it('resolves a transcript by config dir and session id for a plain-named session', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    const filePath = writeTranscript({
+      configDir,
+      cwdSlug: '-home-user',
+      sessionId: 'wb-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.get('workbench')).toBe(filePath);
+  });
+
+  it('chooses the most recently modified match across project directories', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    writeTranscript({
+      configDir,
+      cwdSlug: '-home-user-old',
+      sessionId: 'wb-uuid',
+      mtimeEpochSeconds: 1700000000,
+    });
+    const newerPath = writeTranscript({
+      configDir,
+      cwdSlug: '-home-user-new',
+      sessionId: 'wb-uuid',
+      mtimeEpochSeconds: 1700000500,
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.get('workbench')).toBe(newerPath);
+  });
+
+  it('resolves several sessions in one call', () => {
+    const workbenchConfig = path.join(configRoot, 'workbench');
+    const controlRoomConfig = path.join(configRoot, 'control-room');
+    const workbenchPath = writeTranscript({
+      configDir: workbenchConfig,
+      cwdSlug: '-home-user',
+      sessionId: 'wb-uuid',
+    });
+    const controlRoomPath = writeTranscript({
+      configDir: controlRoomConfig,
+      cwdSlug: '-home-user',
+      sessionId: 'cr-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        configDir: workbenchConfig,
+      },
+      {
+        sessionName: 'control-room',
+        sessionId: 'cr-uuid',
+        configDir: controlRoomConfig,
+      },
+    ]);
+
+    expect(result.get('workbench')).toBe(workbenchPath);
+    expect(result.get('control-room')).toBe(controlRoomPath);
+  });
+
+  it('omits a session whose transcript file is absent', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    fs.mkdirSync(path.join(configDir, 'projects', '-home-user'), {
+      recursive: true,
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'missing-uuid', configDir },
+    ]);
+
+    expect(result.has('workbench')).toBe(false);
+  });
+
+  it('omits a session whose config dir has no projects directory', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    fs.mkdirSync(configDir, { recursive: true });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.has('workbench')).toBe(false);
+  });
+
+  it('returns an empty map for an empty session list', () => {
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([]);
+
+    expect(result.size).toBe(0);
+  });
+});