github-issue-tower-defence-management 1.150.0 → 1.151.1

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.singleScan.test.ts

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TranscriptOwnerCallStatusProvider } from './TranscriptOwnerCallStatusProvider';
+
+describe('TranscriptOwnerCallStatusProvider single transcript scan', () => {
+  let rootDirectory: string;
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'single-scan-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const writeTranscript = (fileName: string, lines: object[]): string => {
+    const filePath = path.join(rootDirectory, fileName);
+    fs.writeFileSync(
+      filePath,
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+    return filePath;
+  };
+
+  const assistantWithMarker = (timestamp: string): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      stop_reason: 'end_turn',
+      content: [
+        { type: 'text', text: 'Waiting <<OWNER_CALL>> please decide.' },
+      ],
+    },
+  });
+
+  const epochSecondsOf = (timestamp: string): number =>
+    Math.floor(Date.parse(timestamp) / 1000);
+
+  it('serves the reminder path and the listing path from one read of the transcript', async () => {
+    const transcriptPath = writeTranscript('session.jsonl', [
+      assistantWithMarker('2026-08-13T10:00:00.000Z'),
+    ]);
+    const transcriptPathBySessionName = new Map([['session', transcriptPath]]);
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+    const calls = await provider.listUnansweredOwnerCallsBySessionName(
+      transcriptPathBySessionName,
+    );
+
+    writeTranscript('session.jsonl', [
+      assistantWithMarker('2026-08-13T11:00:00.000Z'),
+    ]);
+
+    const epochSeconds =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        transcriptPathBySessionName,
+      );
+
+    expect(calls.get('session')).toEqual([
+      {
+        calledAt: '2026-08-13T10:00:00.000Z',
+        body: 'Waiting <<OWNER_CALL>> please decide.',
+      },
+    ]);
+    expect(epochSeconds.get('session')).toBe(
+      epochSecondsOf('2026-08-13T10:00:00.000Z'),
+    );
+  });
+
+  it('scans a transcript that only the reminder path asked for', async () => {
+    const transcriptPath = writeTranscript('reminder-only.jsonl', [
+      assistantWithMarker('2026-08-13T12:00:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+    const epochSeconds =
+      await provider.listUnansweredOwnerCallEpochSecondsBySessionName(
+        new Map([['session', transcriptPath]]),
+      );
+
+    expect(epochSeconds.get('session')).toBe(
+      epochSecondsOf('2026-08-13T12:00:00.000Z'),
+    );
+  });
+});

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

@@ -820,6 +820,184 @@ describe('TranscriptOwnerCallStatusProvider', () => {
       Math.floor(Date.parse('2026-06-27T10:20:00.000Z') / 1000),
     );
   });
+
+  describe('listUnansweredOwnerCallsBySessionName', () => {
+    const assistantCallSaying = (timestamp: string, text: string): object => ({
+      type: 'assistant',
+      timestamp,
+      message: {
+        role: 'assistant',
+        stop_reason: 'end_turn',
+        content: [{ type: 'text', text: `${text} <<OWNER_CALL>>` }],
+      },
+    });
+
+    it('returns the time and the body of an unanswered owner call', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        ownerReply('2026-06-27T09:00:00.000Z'),
+        assistantCallSaying(
+          '2026-06-27T10:00:00.000Z',
+          'Please decide whether to merge the release branch',
+        ),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(result.get(sessionName)).toEqual([
+        {
+          calledAt: '2026-06-27T10:00:00.000Z',
+          body: 'Please decide whether to merge the release branch <<OWNER_CALL>>',
+        },
+      ]);
+    });
+
+    it('returns every owner call raised since the last owner reply, oldest first', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantCallSaying('2026-06-27T08:00:00.000Z', 'answered call'),
+        ownerReply('2026-06-27T09:00:00.000Z'),
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'first waiting call'),
+        assistantCallSaying('2026-06-27T11:30:00.000Z', 'second waiting call'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(
+        result.get(sessionName)?.map((ownerCall) => ownerCall.calledAt),
+      ).toEqual(['2026-06-27T10:00:00.000Z', '2026-06-27T11:30:00.000Z']);
+      expect(result.get(sessionName)?.[0].body).toContain('first waiting call');
+      expect(result.get(sessionName)?.[1].body).toContain(
+        'second waiting call',
+      );
+    });
+
+    it('gives each call of one session a distinct time so the calls stay separable', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'same text'),
+        assistantCallSaying('2026-06-27T11:30:00.000Z', 'same text'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      const calls = result.get(sessionName) ?? [];
+      expect(calls).toHaveLength(2);
+      expect(calls[0].body).toBe(calls[1].body);
+      expect(calls[0].calledAt).not.toBe(calls[1].calledAt);
+    });
+
+    it('keeps a delivered call listed while the newest call is a candidate the status line has not rendered yet', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        ownerReply('2026-06-27T09:00:00.000Z'),
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'delivered call'),
+        assistantWithCandidateMarker('2026-06-27T11:00:00.000Z'),
+      ]);
+      const markerDirectory = path.join(rootDirectory, 'markers');
+      fs.mkdirSync(markerDirectory, { recursive: true });
+      const provider = new TranscriptOwnerCallStatusProvider(
+        '<<OWNER_CALL>>',
+        markerDirectory,
+      );
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(
+        result.get(sessionName)?.map((ownerCall) => ownerCall.calledAt),
+      ).toEqual(['2026-06-27T10:00:00.000Z']);
+    });
+
+    it('omits a call the format gate held and never approved from the listed calls', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        ownerReply('2026-06-27T09:00:00.000Z'),
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'held by the gate'),
+        assistantCallSaying('2026-06-27T11:00:00.000Z', 'delivered call'),
+      ]);
+      const markerDirectory = path.join(rootDirectory, 'markers');
+      writeCallGateMarker(
+        markerDirectory,
+        'workbench.jsonl',
+        '.suppress_ts',
+        '2026-06-27T10:00:00.000Z',
+      );
+      const provider = new TranscriptOwnerCallStatusProvider(
+        '<<OWNER_CALL>>',
+        markerDirectory,
+      );
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(
+        result.get(sessionName)?.map((ownerCall) => ownerCall.calledAt),
+      ).toEqual(['2026-06-27T11:00:00.000Z']);
+    });
+
+    it('lists the calls oldest first even when the transcript records a later call before an earlier one', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantCallSaying('2026-06-27T11:00:00.000Z', 'later call'),
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'earlier call'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(
+        result.get(sessionName)?.map((ownerCall) => ownerCall.calledAt),
+      ).toEqual(['2026-06-27T10:00:00.000Z', '2026-06-27T11:00:00.000Z']);
+    });
+
+    it('returns no entry for a session whose last owner call the owner already answered', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'please decide'),
+        ownerReply('2026-06-27T10:30:00.000Z'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(result.has(sessionName)).toBe(false);
+    });
+
+    it('returns no entry for a session that raised no owner call', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantPlain('2026-06-27T10:00:00.000Z'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(result.has(sessionName)).toBe(false);
+    });
+
+    it('returns nothing when no owner call marker is configured', async () => {
+      const transcriptPath = writeTranscript('workbench.jsonl', [
+        assistantCallSaying('2026-06-27T10:00:00.000Z', 'please decide'),
+      ]);
+      const provider = new TranscriptOwnerCallStatusProvider(null);
+
+      const result = await provider.listUnansweredOwnerCallsBySessionName(
+        new Map([[sessionName, transcriptPath]]),
+      );
+
+      expect(result.size).toBe(0);
+    });
+  });
 });
 
 describe('ownerCallMarkerFamilyResolve', () => {

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -1,8 +1,20 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
+import { UnansweredOwnerCall } from '../../domain/entities/UnansweredOwnerCall';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
 
+type TranscriptOwnerCall = {
+  epochMs: number;
+  body: string;
+  candidateOnly: boolean;
+};
+
+type TranscriptOwnerCallScan = {
+  ownerCalls: TranscriptOwnerCall[];
+  lastOwnerReplyEpochMs: number | null;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;
 
@@ -146,6 +158,11 @@ const isCandidateOwnerCallMarker = (marker: string): boolean =>
 export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
   private readonly ownerCallMarkerFamily: string[];
 
+  private readonly transcriptScanByPath = new Map<
+    string,
+    TranscriptOwnerCallScan | null
+  >();
+
   constructor(
     ownerCallMarker: string | null,
     private readonly ownerReplyMarkerDirectory: string | null = null,
@@ -167,10 +184,8 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
       return unansweredOwnerCallEpochSecondsBySessionName;
     }
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const unansweredOwnerCallEpochMs = this.findUnansweredOwnerCallEpochMs(
-        transcriptPath,
-        this.ownerCallMarkerFamily,
-      );
+      const unansweredOwnerCallEpochMs =
+        this.findUnansweredOwnerCallEpochMs(transcriptPath);
       if (unansweredOwnerCallEpochMs !== null) {
         unansweredOwnerCallEpochSecondsBySessionName.set(
           sessionName,
@@ -181,18 +196,67 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
     return unansweredOwnerCallEpochSecondsBySessionName;
   };
 
-  private findUnansweredOwnerCallEpochMs = (
+  listUnansweredOwnerCallsBySessionName = async (
+    transcriptPathBySessionName: Map<string, string>,
+  ): Promise<Map<string, UnansweredOwnerCall[]>> => {
+    const unansweredOwnerCallsBySessionName = new Map<
+      string,
+      UnansweredOwnerCall[]
+    >();
+    if (this.ownerCallMarkerFamily.length === 0) {
+      return unansweredOwnerCallsBySessionName;
+    }
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      const transcript = this.scanTranscript(transcriptPath);
+      if (transcript === null) {
+        continue;
+      }
+      const answeredBeforeEpochMs = this.resolveReplyEpochMs(
+        transcriptPath,
+        transcript.lastOwnerReplyEpochMs,
+      );
+      const unansweredCalls = transcript.ownerCalls
+        .filter(
+          (ownerCall) =>
+            (answeredBeforeEpochMs === null ||
+              ownerCall.epochMs > answeredBeforeEpochMs) &&
+            this.isCallDeliveredToOwner(transcriptPath, ownerCall),
+        )
+        .sort((oneCall, otherCall) => oneCall.epochMs - otherCall.epochMs)
+        .map((ownerCall) => ({
+          calledAt: new Date(ownerCall.epochMs).toISOString(),
+          body: ownerCall.body,
+        }));
+      if (unansweredCalls.length > 0) {
+        unansweredOwnerCallsBySessionName.set(sessionName, unansweredCalls);
+      }
+    }
+    return unansweredOwnerCallsBySessionName;
+  };
+
+  private scanTranscript = (
     transcriptPath: string,
-    markerFamily: string[],
-  ): number | null => {
+  ): TranscriptOwnerCallScan | null => {
+    const alreadyScanned = this.transcriptScanByPath.get(transcriptPath);
+    if (alreadyScanned !== undefined) {
+      return alreadyScanned;
+    }
+    const scan = this.readTranscriptScan(transcriptPath);
+    this.transcriptScanByPath.set(transcriptPath, scan);
+    return scan;
+  };
+
+  private readTranscriptScan = (
+    transcriptPath: string,
+  ): TranscriptOwnerCallScan | null => {
+    const markerFamily = this.ownerCallMarkerFamily;
     let content: string;
     try {
       content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
       return null;
     }
-    let lastOwnerCallEpochMs: number | null = null;
-    let lastOwnerCallIsCandidateOnly = false;
+    const ownerCalls: TranscriptOwnerCall[] = [];
     let lastOwnerReplyEpochMs: number | null = null;
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
@@ -221,10 +285,11 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
           assistantText.includes(marker),
         );
         if (matchedMarkers.length > 0) {
-          lastOwnerCallEpochMs = epochMs;
-          lastOwnerCallIsCandidateOnly = matchedMarkers.every(
-            isCandidateOwnerCallMarker,
-          );
+          ownerCalls.push({
+            epochMs,
+            body: assistantText,
+            candidateOnly: matchedMarkers.every(isCandidateOwnerCallMarker),
+          });
         }
       }
       if (
@@ -241,27 +306,49 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
             : lastOwnerReplyEpochMs;
       }
     }
-    if (lastOwnerCallEpochMs === null) {
+    return { ownerCalls, lastOwnerReplyEpochMs };
+  };
+
+  private resolveReplyEpochMs = (
+    transcriptPath: string,
+    lastOwnerReplyEpochMs: number | null,
+  ): number | null => {
+    const markerReplyEpochMs = this.readOwnerReplyMarkerEpochMs(transcriptPath);
+    return markerReplyEpochMs !== null &&
+      (lastOwnerReplyEpochMs === null ||
+        markerReplyEpochMs > lastOwnerReplyEpochMs)
+      ? markerReplyEpochMs
+      : lastOwnerReplyEpochMs;
+  };
+
+  private findUnansweredOwnerCallEpochMs = (
+    transcriptPath: string,
+  ): number | null => {
+    const transcript = this.scanTranscript(transcriptPath);
+    if (transcript === null) {
+      return null;
+    }
+    const lastOwnerCall =
+      transcript.ownerCalls[transcript.ownerCalls.length - 1] ?? null;
+    if (lastOwnerCall === null) {
       return null;
     }
+    const lastOwnerCallEpochMs = lastOwnerCall.epochMs;
     if (
       this.isCallSuppressedUndelivered(transcriptPath, lastOwnerCallEpochMs)
     ) {
       return null;
     }
     if (
-      lastOwnerCallIsCandidateOnly &&
+      lastOwnerCall.candidateOnly &&
       !this.isCandidateCallDelivered(transcriptPath, lastOwnerCallEpochMs)
     ) {
       return null;
     }
-    const markerReplyEpochMs = this.readOwnerReplyMarkerEpochMs(transcriptPath);
-    const resolvedReplyEpochMs =
-      markerReplyEpochMs !== null &&
-      (lastOwnerReplyEpochMs === null ||
-        markerReplyEpochMs > lastOwnerReplyEpochMs)
-        ? markerReplyEpochMs
-        : lastOwnerReplyEpochMs;
+    const resolvedReplyEpochMs = this.resolveReplyEpochMs(
+      transcriptPath,
+      transcript.lastOwnerReplyEpochMs,
+    );
     return resolvedReplyEpochMs === null ||
       lastOwnerCallEpochMs > resolvedReplyEpochMs
       ? lastOwnerCallEpochMs
@@ -285,6 +372,19 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
   // on the owner would silence the session's stall reminder for good — the session would keep its
   // task and never be woken again. Such a call is therefore not an outstanding owner call here. A
   // delivered call, and a newer call the suppression marker does not name, are untouched.
+  private isCallDeliveredToOwner = (
+    transcriptPath: string,
+    ownerCall: TranscriptOwnerCall,
+  ): boolean => {
+    if (this.isCallSuppressedUndelivered(transcriptPath, ownerCall.epochMs)) {
+      return false;
+    }
+    return (
+      !ownerCall.candidateOnly ||
+      this.isCandidateCallDelivered(transcriptPath, ownerCall.epochMs)
+    );
+  };
+
   private isCallSuppressedUndelivered = (
     transcriptPath: string,
     ownerCallEpochMs: number,

package/src/domain/entities/UnansweredOwnerCall.ts

@@ -0,0 +1,4 @@
+export type UnansweredOwnerCall = {
+  calledAt: string;
+  body: string;
+};

package/src/domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase.test.ts

@@ -1,6 +1,8 @@
 import { Issue } from '../../entities/Issue';
 import { FieldOption, Project } from '../../entities/Project';
 import { GenerateInTmuxByHumanDataUseCase } from './GenerateInTmuxByHumanDataUseCase';
+import { UnansweredOwnerCall } from '../../entities/UnansweredOwnerCall';
+import { toTmuxSessionName } from './InTmuxByHumanSessionReconcileUseCase';
 
 const ASSIGNEE = 'owner-login';
 const CONSOLE_BASE_URL = 'https://console.example.test';
@@ -98,6 +100,7 @@ describe('GenerateInTmuxByHumanDataUseCase', () => {
       consoleBaseUrl?: string | null;
       consoleToken?: string | null;
       newIssueRepo?: string;
+      unansweredCallsByTmuxSessionName?: Map<string, UnansweredOwnerCall[]>;
     } = {},
   ) =>
     usecase.run({
@@ -116,6 +119,9 @@ describe('GenerateInTmuxByHumanDataUseCase', () => {
         overrides.consoleToken === undefined
           ? CONSOLE_TOKEN
           : overrides.consoleToken,
+      unansweredCallsByTmuxSessionName:
+        overrides.unansweredCallsByTmuxSessionName ??
+        new Map<string, UnansweredOwnerCall[]>(),
       now: NOW,
     });
 
@@ -333,4 +339,97 @@ describe('GenerateInTmuxByHumanDataUseCase', () => {
       expect(result.v3).not.toBeNull();
     });
   });
+
+  describe('v5 document', () => {
+    const callsFor = (
+      issueUrl: string,
+      calls: UnansweredOwnerCall[],
+    ): Map<string, UnansweredOwnerCall[]> =>
+      new Map([[toTmuxSessionName(issueUrl), calls]]);
+
+    it('builds version 5 with key order version, overviewUrl, tdpmConsoleUrl, newIssueUrl, groups', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v5).not.toBeNull();
+      expect(Object.keys(result.v5 ?? {})).toEqual([
+        'version',
+        'overviewUrl',
+        'tdpmConsoleUrl',
+        'newIssueUrl',
+        'groups',
+      ]);
+      expect(result.v5?.version).toBe(5);
+    });
+
+    it('gives a session with no unanswered call an empty unansweredCalls array', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v5?.groups).toEqual([
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+              unansweredCalls: [],
+            },
+          ],
+        },
+      ]);
+    });
+
+    it('carries the unanswered calls of a session looked up by the tmux session name the reconciler derives from the issue url', () => {
+      const issue = makeIssue({ story: 'Story Alpha' });
+      const call: UnansweredOwnerCall = {
+        calledAt: '2026-08-13T10:14:00.000Z',
+        body: 'Please decide whether to merge the release branch',
+      };
+
+      const result = run([issue], {
+        unansweredCallsByTmuxSessionName: callsFor(issue.url, [call]),
+      });
+
+      expect(result.v5?.groups[0].sessions[0].unansweredCalls).toEqual([call]);
+    });
+
+    it('carries every unanswered call of one session in call order with its own time and body', () => {
+      const issue = makeIssue({ story: 'Story Alpha' });
+      const calls: UnansweredOwnerCall[] = [
+        { calledAt: '2026-08-13T10:14:00.000Z', body: 'first call body' },
+        { calledAt: '2026-08-13T10:41:30.000Z', body: 'second call body' },
+      ];
+
+      const result = run([issue], {
+        unansweredCallsByTmuxSessionName: callsFor(issue.url, calls),
+      });
+
+      expect(result.v5?.groups[0].sessions[0].unansweredCalls).toEqual(calls);
+      expect(
+        result.v5?.groups[0].sessions[0].unansweredCalls.map(
+          (unansweredCall) => unansweredCall.calledAt,
+        ),
+      ).toEqual(['2026-08-13T10:14:00.000Z', '2026-08-13T10:41:30.000Z']);
+    });
+
+    it('leaves the version 4 document free of unanswered call data', () => {
+      const issue = makeIssue({ story: 'Story Alpha' });
+
+      const result = run([issue], {
+        unansweredCallsByTmuxSessionName: callsFor(issue.url, [
+          { calledAt: '2026-08-13T10:14:00.000Z', body: 'first call body' },
+        ]),
+      });
+
+      expect(result.v4?.groups[0].sessions[0]).toEqual({
+        name: 'https://github.com/demo/repo/issues/1',
+        description: 'Issue 1',
+      });
+    });
+
+    it('is null when the console token is unset while v3 is still produced', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })], {
+        consoleToken: null,
+      });
+      expect(result.v5).toBeNull();
+      expect(result.v3).not.toBeNull();
+    });
+  });
 });