github-issue-tower-defence-management 1.149.1 → 1.151.0

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;
 
@@ -181,18 +193,58 @@ 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,
+        this.ownerCallMarkerFamily,
+      );
+      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 => {
     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 +273,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 +294,50 @@ 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,
+    markerFamily: string[],
+  ): number | null => {
+    const transcript = this.scanTranscript(transcriptPath, markerFamily);
+    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 +361,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/LiveSessionOauthTokenSelectUseCase.test.ts

@@ -476,6 +476,39 @@ describe('LiveSessionOauthTokenSelectUseCase', () => {
   });
 });
 
+describe('LiveSessionOauthTokenCandidateMetrics selectionWeight', () => {
+  const useCase = new LiveSessionOauthTokenSelectUseCase();
+
+  it('includes the configured selection weight in each candidate metric', () => {
+    const result = useCase.run(
+      [
+        withSelectionWeight(candidate('heavy', snapshot({})), 2),
+        candidate('normal', snapshot({})),
+      ],
+      [],
+      NOW,
+      SETTINGS,
+    );
+
+    const heavy = result.metrics.find((m) => m.name === 'heavy');
+    const normal = result.metrics.find((m) => m.name === 'normal');
+    expect(heavy?.selectionWeight).toBe(2);
+    expect(normal?.selectionWeight).toBe(1);
+  });
+
+  it('reports selection weight one for a candidate without an explicit selectionWeight', () => {
+    const result = useCase.run(
+      [candidate('implicit', snapshot({}))],
+      [],
+      NOW,
+      SETTINGS,
+    );
+
+    const implicit = result.metrics.find((m) => m.name === 'implicit');
+    expect(implicit?.selectionWeight).toBe(1);
+  });
+});
+
 describe('liveSessionConcurrentLimitOf', () => {
   it('gives the full limit while the five hour window is at or above the full speed free ratio', () => {
     expect(liveSessionConcurrentLimitOf(1, 1, SETTINGS)).toBe(

package/src/domain/usecases/LiveSessionOauthTokenSelectUseCase.ts

@@ -1,6 +1,6 @@
-import { ClaudeLiveSession } from './adapter-interfaces/ClaudeLiveSessionRepository';
+import type { ClaudeLiveSession } from './adapter-interfaces/ClaudeLiveSessionRepository';
 import {
-  OauthTokenCandidate,
+  type OauthTokenCandidate,
   OauthTokenSelectUseCase,
   selectionWeightOf,
 } from './OauthTokenSelectUseCase';
@@ -45,6 +45,7 @@ export type LiveSessionOauthTokenCandidateMetrics = {
   hasConcurrencyHeadroom: boolean;
   eligible: boolean;
   exclusionReason: string | null;
+  selectionWeight: number;
 };
 
 export type LiveSessionOauthTokenSelectResult = {
@@ -91,6 +92,7 @@ export class LiveSessionOauthTokenSelectUseCase {
           hasConcurrencyHeadroom: liveSessionCount < concurrentSessionLimit,
           eligible: rateLimitMetric.eligible,
           exclusionReason: rateLimitMetric.exclusionReason,
+          selectionWeight: selectionWeightOf(candidate),
         },
       };
     });

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

@@ -439,6 +439,94 @@ describe('OauthTokenSelectUseCase selectionWeight', () => {
   });
 });
 
+describe('OauthTokenCandidateMetrics drawWeight', () => {
+  const useCase = new OauthTokenSelectUseCase();
+
+  it('reports draw weight zero for an ineligible candidate', () => {
+    const result = useCase.run(
+      [
+        candidate('busy5h', snapshot({ fiveHourUtilization: 0.9 })),
+        candidate('ok', snapshot({})),
+      ],
+      NOW,
+    );
+
+    const busy = result.metrics.find((m) => m.name === 'busy5h');
+    expect(busy?.drawWeight).toBe(0);
+  });
+
+  it('reports a positive draw weight for an eligible candidate', () => {
+    const result = useCase.run(
+      [candidate('eligible', snapshot({ sevenDayReset: NOW + 2 * DAY }))],
+      NOW,
+    );
+
+    const eligible = result.metrics.find((m) => m.name === 'eligible');
+    expect(eligible?.drawWeight).toBeGreaterThan(0);
+  });
+
+  it('gives a higher draw weight to a candidate whose 7d window resets sooner', () => {
+    const result = useCase.run(
+      [
+        candidate('soon', snapshot({ sevenDayReset: NOW + 2 * DAY })),
+        candidate('far', snapshot({ sevenDayReset: NOW + 6 * DAY })),
+      ],
+      NOW,
+    );
+
+    const soon = result.metrics.find((m) => m.name === 'soon');
+    const far = result.metrics.find((m) => m.name === 'far');
+    expect(soon?.drawWeight ?? 0).toBeGreaterThan(far?.drawWeight ?? 0);
+  });
+
+  it('scales draw weight by the configured selection weight', () => {
+    const result = useCase.run(
+      [
+        withSelectionWeight(
+          candidate('double', snapshot({ sevenDayReset: NOW + 2 * DAY })),
+          2,
+        ),
+        withSelectionWeight(
+          candidate('single', snapshot({ sevenDayReset: NOW + 2 * DAY })),
+          1,
+        ),
+      ],
+      NOW,
+    );
+
+    const double = result.metrics.find((m) => m.name === 'double');
+    const single = result.metrics.find((m) => m.name === 'single');
+    expect(double?.drawWeight).toBeCloseTo((single?.drawWeight ?? 0) * 2, 5);
+  });
+
+  it('draws on exactly the weight it reports, so the trace cannot disagree with the draw', () => {
+    const candidates = [
+      withSelectionWeight(
+        candidate('double', snapshot({ sevenDayReset: NOW + 2 * DAY })),
+        2,
+      ),
+      withSelectionWeight(
+        candidate('single', snapshot({ sevenDayReset: NOW + 2 * DAY })),
+        1,
+      ),
+    ];
+
+    const reported = useCase.run(candidates, NOW, () => 0).metrics;
+    const doubleWeight =
+      reported.find((m) => m.name === 'double')?.drawWeight ?? 0;
+    const singleWeight =
+      reported.find((m) => m.name === 'single')?.drawWeight ?? 0;
+    const boundary = doubleWeight / (doubleWeight + singleWeight);
+
+    expect(
+      useCase.run(candidates, NOW, () => boundary - 0.01).selected?.name,
+    ).toBe('double');
+    expect(
+      useCase.run(candidates, NOW, () => boundary + 0.01).selected?.name,
+    ).toBe('single');
+  });
+});
+
 describe('sevenDayUrgencyFactor', () => {
   const now = 1_000_000;
 

package/src/domain/usecases/OauthTokenSelectUseCase.ts

@@ -31,6 +31,7 @@ export type OauthTokenCandidateMetrics = {
   sevenDayEndEpoch: number;
   eligible: boolean;
   exclusionReason: string | null;
+  drawWeight: number;
 };
 
 export type OauthTokenSelectResult = {
@@ -91,13 +92,26 @@ export class OauthTokenSelectUseCase {
     nowEpochSeconds: number,
     random: SelectionRandom = Math.random,
   ): OauthTokenSelectResult => {
-    const evaluated = candidates.map((candidate) => ({
-      candidate,
-      metric: this.evaluate(candidate, nowEpochSeconds),
-    }));
+    const evaluated = candidates.map((candidate) => {
+      const evaluatedMetric = this.evaluate(candidate, nowEpochSeconds);
+      return {
+        candidate,
+        metric: {
+          ...evaluatedMetric,
+          drawWeight: evaluatedMetric.eligible
+            ? selectionWeightOf(candidate) *
+              sevenDayUrgencyFactor(
+                evaluatedMetric.sevenDayFreeRatio,
+                evaluatedMetric.sevenDayEndEpoch,
+                nowEpochSeconds,
+              )
+            : 0,
+        },
+      };
+    });
 
-    const metrics = evaluated.map((entry) => entry.metric);
     const eligible = evaluated.filter((entry) => entry.metric.eligible);
+    const metrics = evaluated.map((entry) => entry.metric);
 
     if (eligible.length === 0) {
       return { selected: null, metrics };
@@ -111,13 +125,7 @@ export class OauthTokenSelectUseCase {
 
     const selected = selectWeightedCandidate(
       eligible,
-      (entry) =>
-        selectionWeightOf(entry.candidate) *
-        sevenDayUrgencyFactor(
-          entry.metric.sevenDayFreeRatio,
-          entry.metric.sevenDayEndEpoch,
-          nowEpochSeconds,
-        ),
+      (entry) => entry.metric.drawWeight,
       deterministicBest,
       random,
     );
@@ -128,7 +136,7 @@ export class OauthTokenSelectUseCase {
   private evaluate = (
     candidate: OauthTokenCandidate,
     nowEpochSeconds: number,
-  ): OauthTokenCandidateMetrics => {
+  ): Omit<OauthTokenCandidateMetrics, 'drawWeight'> => {
     const fiveHourFreeRatio = this.fiveHourFreeRatio(
       candidate.snapshot,
       nowEpochSeconds,