npm - github-issue-tower-defence-management - Versions diffs - 1.113.0 → 1.114.1 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-DfNrA5uV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CEJmPNRK.css">
+    <script type="module" crossorigin src="/assets/index-DQyZ8KpG.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Blb_xqIx.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -5,11 +5,13 @@ import { FileSystemInteractiveLiveSessionTranscriptResolver } from './FileSystem
 describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
   let configRoot: string;
+  let sharedProjectsDirectory: string;
   beforeEach(() => {
     configRoot = fs.mkdtempSync(
       path.join(os.tmpdir(), 'interactive-transcript-'),
     );
+    sharedProjectsDirectory = path.join(configRoot, 'shared', 'projects');
   });
   afterEach(() => {
@@ -17,14 +19,13 @@ describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
   });
   const writeTranscript = (params: {
-    configDir: string;
+    projectsDirectory: string;
     cwdSlug: string;
     sessionId: string;
     mtimeEpochSeconds?: number;
   }): string => {
     const projectDirectory = path.join(
-      params.configDir,
-      'projects',
+      params.projectsDirectory,
       params.cwdSlug,
     );
     fs.mkdirSync(projectDirectory, { recursive: true });
@@ -40,40 +41,100 @@ describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
     return filePath;
   };
-  it('resolves a transcript by config dir and session id for a plain-named session', () => {
+  it('resolves a resume-case transcript by config dir and session id', () => {
     const configDir = path.join(configRoot, 'workbench');
     const filePath = writeTranscript({
-      configDir,
+      projectsDirectory: path.join(configDir, 'projects'),
       cwdSlug: '-home-user',
       sessionId: 'wb-uuid',
     });
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([
-      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        candidateSessionIds: ['wb-uuid'],
+        configDir,
+      },
     ]);
     expect(result.get('workbench')).toBe(filePath);
   });
-  it('chooses the most recently modified match across project directories', () => {
+  it('resolves a rotated-id transcript via a later candidate session id', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    const rotatedPath = writeTranscript({
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'rotated-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'workbench',
+        sessionId: 'launch-uuid',
+        candidateSessionIds: ['rotated-uuid', 'launch-uuid'],
+        configDir,
+      },
+    ]);
+    expect(result.get('workbench')).toBe(rotatedPath);
+  });
+  it('resolves a transcript that lives under the shared projects directory', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    const sharedPath = writeTranscript({
+      projectsDirectory: sharedProjectsDirectory,
+      cwdSlug: '-home-user',
+      sessionId: 'rotated-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'workbench',
+        sessionId: 'launch-uuid',
+        candidateSessionIds: ['rotated-uuid', 'launch-uuid'],
+        configDir,
+      },
+    ]);
+    expect(result.get('workbench')).toBe(sharedPath);
+  });
+  it('prefers the most recently modified match across both projects roots', () => {
     const configDir = path.join(configRoot, 'workbench');
     writeTranscript({
-      configDir,
-      cwdSlug: '-home-user-old',
-      sessionId: 'wb-uuid',
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'rotated-uuid',
       mtimeEpochSeconds: 1700000000,
     });
     const newerPath = writeTranscript({
-      configDir,
-      cwdSlug: '-home-user-new',
-      sessionId: 'wb-uuid',
+      projectsDirectory: sharedProjectsDirectory,
+      cwdSlug: '-home-user',
+      sessionId: 'rotated-uuid',
       mtimeEpochSeconds: 1700000500,
     });
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([
-      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+      {
+        sessionName: 'workbench',
+        sessionId: 'launch-uuid',
+        candidateSessionIds: ['rotated-uuid', 'launch-uuid'],
+        configDir,
+      },
     ]);
     expect(result.get('workbench')).toBe(newerPath);
@@ -83,26 +144,30 @@ describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
     const workbenchConfig = path.join(configRoot, 'workbench');
     const controlRoomConfig = path.join(configRoot, 'control-room');
     const workbenchPath = writeTranscript({
-      configDir: workbenchConfig,
+      projectsDirectory: path.join(workbenchConfig, 'projects'),
       cwdSlug: '-home-user',
       sessionId: 'wb-uuid',
     });
     const controlRoomPath = writeTranscript({
-      configDir: controlRoomConfig,
+      projectsDirectory: path.join(controlRoomConfig, 'projects'),
       cwdSlug: '-home-user',
       sessionId: 'cr-uuid',
     });
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([
       {
         sessionName: 'workbench',
         sessionId: 'wb-uuid',
+        candidateSessionIds: ['wb-uuid'],
         configDir: workbenchConfig,
       },
       {
         sessionName: 'control-room',
         sessionId: 'cr-uuid',
+        candidateSessionIds: ['cr-uuid'],
         configDir: controlRoomConfig,
       },
     ]);
@@ -111,34 +176,50 @@ describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
     expect(result.get('control-room')).toBe(controlRoomPath);
   });
-  it('omits a session whose transcript file is absent', () => {
+  it('omits a session whose transcript file is absent in both roots', () => {
     const configDir = path.join(configRoot, 'workbench');
     fs.mkdirSync(path.join(configDir, 'projects', '-home-user'), {
       recursive: true,
     });
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([
-      { sessionName: 'workbench', sessionId: 'missing-uuid', configDir },
+      {
+        sessionName: 'workbench',
+        sessionId: 'missing-uuid',
+        candidateSessionIds: ['missing-uuid'],
+        configDir,
+      },
     ]);
     expect(result.has('workbench')).toBe(false);
   });
-  it('omits a session whose config dir has no projects directory', () => {
+  it('omits a session when neither projects directory exists', () => {
     const configDir = path.join(configRoot, 'workbench');
     fs.mkdirSync(configDir, { recursive: true });
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([
-      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        candidateSessionIds: ['wb-uuid'],
+        configDir,
+      },
     ]);
     expect(result.has('workbench')).toBe(false);
   });
   it('returns an empty map for an empty session list', () => {
-    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
     const result = resolver.resolveTranscriptPaths([]);

package/src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.ts CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

package/src/domain/entities/LiveSessionProcessSnapshot.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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',
     });
   });