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

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

@@ -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,146 @@ 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 non-resume session to the descendant id file when the own launch id file is absent', () => {
+    const configDir = path.join(configRoot, 'non-resume');
+    const harnessPath = writeTranscript({
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'harness-id',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'non-resume',
+        sessionId: 'launch-id',
+        candidateSessionIds: ['launch-id', 'harness-id'],
+        configDir,
+      },
+    ]);
+
+    expect(result.get('non-resume')).toBe(harnessPath);
+  });
+
+  it('resolves a resume session to the own id file when descendants share the own id', () => {
+    const configDir = path.join(configRoot, 'resume');
+    const ownPath = writeTranscript({
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'own-id',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'resume',
+        sessionId: 'own-id',
+        candidateSessionIds: ['own-id', 'own-id'],
+        configDir,
+      },
+    ]);
+
+    expect(result.get('resume')).toBe(ownPath);
+  });
+
+  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 +190,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 +222,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

@@ -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/FileSystemSessionOutputActivityRepository.test.ts

@@ -31,6 +31,17 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     message: { role: 'user', content: 'go ahead' },
   });
 
+  const toolResultEntry = (timestamp: string): object => ({
+    type: 'tool_result',
+    timestamp,
+    toolUseResult: { stdout: 'done', stderr: '' },
+  });
+
+  const untimestampedEntry = (): object => ({
+    type: 'summary',
+    summary: 'no timestamp on this entry',
+  });
+
   const writeTranscript = (fileName: string, lines: object[]): string => {
     const filePath = path.join(rootDirectory, fileName);
     fs.writeFileSync(
@@ -41,7 +52,7 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     return filePath;
   };
 
-  it('returns the latest assistant entry timestamp as the last output epoch', async () => {
+  it('returns the latest entry timestamp of any type as the last activity epoch', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
       userEntry('2026-06-27T10:30:00.000Z'),
@@ -57,13 +68,13 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:30:00.000Z') / 1000,
         ),
       },
     ]);
   });
 
-  it('ignores user entries when computing the last output epoch', async () => {
+  it('advances the last activity time when a later user entry follows an assistant entry', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
       userEntry('2026-06-27T11:00:00.000Z'),
@@ -78,7 +89,28 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T11:00:00.000Z') / 1000,
+        ),
+      },
+    ]);
+  });
+
+  it('advances the last activity time when a tool_result entry is the latest entry', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:45:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:45:00.000Z') / 1000,
         ),
       },
     ]);
@@ -107,7 +139,7 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     ]);
   });
 
-  it('omits sessions whose transcript has no assistant entry', async () => {
+  it('resolves a transcript whose only entry is a non-assistant entry', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       userEntry('2026-06-27T10:00:00.000Z'),
     ]);
@@ -117,6 +149,26 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       new Map([['workbench', transcriptPath]]),
     );
 
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
+    ]);
+  });
+
+  it('omits sessions whose transcript has no parseable timestamp', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      untimestampedEntry(),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
     expect(result).toEqual([]);
   });
 

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -22,11 +22,14 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
 };
 
 /**
- * Reads the last main-session output time for each live session from its
+ * Reads the last main-session activity 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.
+ * the latest entry of any kind (assistant text, owner replies, tool results, or
+ * any other entry type) rather than from the transcript file modification time.
+ * Because a session that is actively running tool calls keeps appending entries
+ * such as `user` and `tool_result` even while it emits no assistant text, every
+ * entry with a parseable timestamp counts as activity, so a working session is
+ * not mistaken for a silent one.
  */
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
@@ -35,7 +38,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
       const lastOutputEpochSeconds =
-        this.readLastAssistantOutputEpochSeconds(transcriptPath);
+        this.readLastActivityEpochSeconds(transcriptPath);
       if (lastOutputEpochSeconds !== null) {
         activities.push({ sessionName, lastOutputEpochSeconds });
       }
@@ -43,7 +46,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     return activities;
   };
 
-  private readLastAssistantOutputEpochSeconds = (
+  private readLastActivityEpochSeconds = (
     transcriptPath: string,
   ): number | null => {
     let content: string;
@@ -52,7 +55,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     } catch {
       return null;
     }
-    let lastAssistantEpochMs: number | null = null;
+    let lastActivityEpochMs: number | null = null;
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -67,20 +70,17 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       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 (lastActivityEpochMs === null || epochMs > lastActivityEpochMs) {
+        lastActivityEpochMs = epochMs;
       }
     }
-    if (lastAssistantEpochMs === null) {
+    if (lastActivityEpochMs === null) {
       return null;
     }
-    return Math.floor(lastAssistantEpochMs / 1000);
+    return Math.floor(lastActivityEpochMs / 1000);
   };
 }

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;
+  };
+}