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

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/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();
+    });
+  });
 });

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

@@ -1,5 +1,7 @@
 import { Issue } from '../../entities/Issue';
 import { FieldOption, Project } from '../../entities/Project';
+import { UnansweredOwnerCall } from '../../entities/UnansweredOwnerCall';
+import { toTmuxSessionName } from './InTmuxByHumanSessionReconcileUseCase';
 
 export type InTmuxByHumanUrlEntry = {
   url: string;
@@ -26,6 +28,17 @@ export type InTmuxByHumanGroupV4 = {
   sessions: InTmuxByHumanSession[];
 };
 
+export type InTmuxByHumanSessionV5 = {
+  name: string;
+  description: string;
+  unansweredCalls: UnansweredOwnerCall[];
+};
+
+export type InTmuxByHumanGroupV5 = {
+  story: string;
+  sessions: InTmuxByHumanSessionV5[];
+};
+
 export type InTmuxByHumanV3 = {
   version: 3;
   overviewUrl: string;
@@ -41,11 +54,20 @@ export type InTmuxByHumanV4 = {
   groups: InTmuxByHumanGroupV4[];
 };
 
+export type InTmuxByHumanV5 = {
+  version: 5;
+  overviewUrl: string;
+  tdpmConsoleUrl: string;
+  newIssueUrl: string;
+  groups: InTmuxByHumanGroupV5[];
+};
+
 export type InTmuxByHumanData = {
   v1: InTmuxByHumanGroupV1[];
   v2: InTmuxByHumanGroupV2[];
   v3: InTmuxByHumanV3 | null;
   v4: InTmuxByHumanV4 | null;
+  v5: InTmuxByHumanV5 | null;
 };
 
 export type GenerateInTmuxByHumanDataInput = {
@@ -58,6 +80,7 @@ export type GenerateInTmuxByHumanDataInput = {
   newIssueRepo?: string;
   consoleBaseUrl: string | null;
   consoleToken: string | null;
+  unansweredCallsByTmuxSessionName: Map<string, UnansweredOwnerCall[]>;
   now: Date;
 };
 
@@ -81,6 +104,7 @@ export class GenerateInTmuxByHumanDataUseCase {
       newIssueRepo,
       consoleBaseUrl,
       consoleToken,
+      unansweredCallsByTmuxSessionName,
     } = input;
 
     const storyOrder = project.story
@@ -114,6 +138,17 @@ export class GenerateInTmuxByHumanDataUseCase {
       })),
     }));
 
+    const v5Groups: InTmuxByHumanGroupV5[] = groups.map((group) => ({
+      story: group.story,
+      sessions: group.issues.map((issue) => ({
+        name: issue.url,
+        description: issue.title,
+        unansweredCalls:
+          unansweredCallsByTmuxSessionName.get(toTmuxSessionName(issue.url)) ??
+          [],
+      })),
+    }));
+
     const overviewUrl = project.url;
     const tdpmConsoleUrl = consoleBaseUrl
       ? `${consoleBaseUrl}/projects/${pjcode}`
@@ -139,7 +174,18 @@ export class GenerateInTmuxByHumanDataUseCase {
           }
         : null;
 
-    return { v1, v2, v3, v4 };
+    const v5: InTmuxByHumanV5 | null =
+      tdpmConsoleUrl && consoleToken
+        ? {
+            version: 5,
+            overviewUrl,
+            tdpmConsoleUrl: `${tdpmConsoleUrl}?k=${consoleToken}`,
+            newIssueUrl: `https://github.com/${org}/${newIssueRepo ?? repo}/issues/new?assignees=${assigneeLogin}`,
+            groups: v5Groups,
+          }
+        : null;
+
+    return { v1, v2, v3, v4, v5 };
   };
 
   private isInTmuxByHuman = (issue: Issue, assigneeLogin: string): boolean =>

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

@@ -0,0 +1,141 @@
+import { Issue } from '../../entities/Issue';
+import { IN_TMUX_STATUS_NAME } from '../../entities/WorkflowStatus';
+import { FieldOption, Project } from '../../entities/Project';
+import { UnansweredOwnerCall } from '../../entities/UnansweredOwnerCall';
+import { IssueRepository } from '../adapter-interfaces/IssueRepository';
+import { TmuxSessionRepository } from '../adapter-interfaces/TmuxSessionRepository';
+import { InTmuxByHumanSessionReconcileUseCase } from './InTmuxByHumanSessionReconcileUseCase';
+import { GenerateInTmuxByHumanDataUseCase } from './GenerateInTmuxByHumanDataUseCase';
+
+const ASSIGNEE = 'owner-login';
+const LAUNCHER = 'cl';
+const NOW = new Date('2026-06-25T12:00:00.000Z');
+const ISSUE_URL = 'https://github.com/demo/repo/issues/1';
+const STORY_NAME = 'Story Alpha';
+
+const fieldOption = (id: string, name: string): FieldOption => ({
+  id,
+  name,
+  color: 'BLUE',
+  description: '',
+});
+
+const projectWithStory: Project = {
+  id: 'project-node-id',
+  url: 'https://github.com/orgs/demo/projects/1',
+  databaseId: 1,
+  name: 'demo',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field',
+    statuses: [fieldOption('st-tmux', IN_TMUX_STATUS_NAME)],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: {
+    name: 'story',
+    fieldId: 'story-field',
+    databaseId: 2,
+    stories: [fieldOption('s1', STORY_NAME)],
+    workflowManagementStory: { id: 'wm', name: 'workflow management' },
+  },
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+};
+
+const inTmuxIssue: Issue = {
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: IN_TMUX_STATUS_NAME,
+  story: STORY_NAME,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: ISSUE_URL,
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: NOW,
+  author: '',
+  closingIssueReferenceUrls: [],
+};
+
+const tmuxSessionNameTheReconcilerCreatesFor = async (
+  issue: Issue,
+): Promise<string> => {
+  const launchedSessionNames: string[] = [];
+  const tmuxSessionRepository: TmuxSessionRepository = {
+    listLiveSessionNames: async () => [],
+    listLiveSessionsWithActivity: async () => [],
+    listInteractiveProcessCommandLines: async () => [],
+    launchDetachedSession: async (sessionName: string) => {
+      launchedSessionNames.push(sessionName);
+    },
+    killSession: async () => undefined,
+    killOwnSession: async () => undefined,
+    sendKeys: async () => undefined,
+    launchBareNameLeaderSession: async () => undefined,
+  };
+  const issueStateRepository: Pick<
+    IssueRepository,
+    'getIssueOrPullRequestState'
+  > = {
+    getIssueOrPullRequestState: async () => ({
+      state: 'OPEN',
+      merged: false,
+      isPullRequest: false,
+      title: 'Issue 1',
+    }),
+  };
+
+  await new InTmuxByHumanSessionReconcileUseCase(
+    tmuxSessionRepository,
+    issueStateRepository,
+  ).run({
+    issues: [issue],
+    assigneeLogin: ASSIGNEE,
+    launcherCommand: LAUNCHER,
+    now: NOW,
+  });
+
+  return launchedSessionNames[0];
+};
+
+describe('unanswered owner call session key contract', () => {
+  it('reads the calls under the very tmux session name the reconciler creates for that issue', async () => {
+    const call: UnansweredOwnerCall = {
+      calledAt: '2026-06-25T11:00:00.000Z',
+      body: 'Please decide whether to merge the release branch',
+    };
+    const sessionNameTheReconcilerCreates =
+      await tmuxSessionNameTheReconcilerCreatesFor(inTmuxIssue);
+
+    const result = new GenerateInTmuxByHumanDataUseCase().run({
+      project: projectWithStory,
+      issues: [inTmuxIssue],
+      pjcode: 'demo',
+      assigneeLogin: ASSIGNEE,
+      org: 'demo',
+      repo: 'repo',
+      consoleBaseUrl: 'https://console.example.test',
+      consoleToken: 'test-token-value',
+      unansweredCallsByTmuxSessionName: new Map([
+        [sessionNameTheReconcilerCreates, [call]],
+      ]),
+      now: NOW,
+    });
+
+    expect(result.v5?.groups[0].sessions[0].unansweredCalls).toEqual([call]);
+  });
+});

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AA4CA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAqD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAqwBP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAkDA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAqD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA6yBP;CACH"}

package/types/adapter/entry-points/handlers/inTmuxByHumanDataWriter.d.ts

@@ -1,5 +1,6 @@
 import type { Issue } from '../../../domain/entities/Issue';
 import type { Project } from '../../../domain/entities/Project';
+import type { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
 export type InTmuxByHumanDataWriterParams = {
     inTmuxDataOutputDir: string | null | undefined;
     inTmuxConsoleBaseUrl: string | null | undefined;
@@ -12,6 +13,7 @@ export type InTmuxByHumanDataWriterParams = {
     newIssueRepo?: string | null | undefined;
     project: Project;
     issues: Issue[];
+    unansweredCallsByTmuxSessionName?: Map<string, UnansweredOwnerCall[]>;
     now: Date;
 };
 export declare const writeInTmuxByHumanData: (params: InTmuxByHumanDataWriterParams) => void;

package/types/adapter/entry-points/handlers/inTmuxByHumanDataWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inTmuxByHumanDataWriter.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAMhE,MAAM,MAAM,6BAA6B,GAAG;IAC1C,mBAAmB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9C,kBAAkB,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAUF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,6BAA6B,KACpC,IA0EF,CAAC"}
+{"version":3,"file":"inTmuxByHumanDataWriter.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAMxF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,mBAAmB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9C,kBAAkB,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,gCAAgC,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC;IACtE,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAUF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,6BAA6B,KACpC,IA2FF,CAAC"}

package/types/adapter/entry-points/handlers/resolveUnansweredOwnerCalls.d.ts

@@ -0,0 +1,13 @@
+import { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
+import { LiveSessionProcessSnapshotProvider } from '../../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { InteractiveLiveSessionTranscriptResolver } from '../../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+export type UnansweredOwnerCallListProvider = {
+    listUnansweredOwnerCallsBySessionName: (transcriptPathBySessionName: Map<string, string>) => Promise<Map<string, UnansweredOwnerCall[]>>;
+};
+export type ResolveUnansweredOwnerCallsParams = {
+    liveSessionProcessSnapshotProvider: LiveSessionProcessSnapshotProvider;
+    interactiveLiveSessionTranscriptResolver: InteractiveLiveSessionTranscriptResolver;
+    unansweredOwnerCallListProvider: UnansweredOwnerCallListProvider;
+};
+export declare const resolveUnansweredOwnerCallsByTmuxSessionName: (params: ResolveUnansweredOwnerCallsParams) => Promise<Map<string, UnansweredOwnerCall[]>>;
+//# sourceMappingURL=resolveUnansweredOwnerCalls.d.ts.map

package/types/adapter/entry-points/handlers/resolveUnansweredOwnerCalls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveUnansweredOwnerCalls.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/resolveUnansweredOwnerCalls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAGnF,OAAO,EAAE,kCAAkC,EAAE,MAAM,gFAAgF,CAAC;AACpI,OAAO,EAAE,wCAAwC,EAAE,MAAM,sFAAsF,CAAC;AAEhJ,MAAM,MAAM,+BAA+B,GAAG;IAC5C,qCAAqC,EAAE,CACrC,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC7C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,kCAAkC,EAAE,kCAAkC,CAAC;IACvE,wCAAwC,EAAE,wCAAwC,CAAC;IACnF,+BAA+B,EAAE,+BAA+B,CAAC;CAClE,CAAC;AAEF,eAAO,MAAM,4CAA4C,GACvD,QAAQ,iCAAiC,KACxC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAY5C,CAAC"}

package/types/adapter/repositories/TranscriptOwnerCallStatusProvider.d.ts

@@ -1,12 +1,17 @@
 import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
+import { UnansweredOwnerCall } from '../../domain/entities/UnansweredOwnerCall';
 export declare const ownerCallMarkerFamilyResolve: (marker: string) => string[];
 export declare class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
     private readonly ownerReplyMarkerDirectory;
     private readonly ownerCallMarkerFamily;
     constructor(ownerCallMarker: string | null, ownerReplyMarkerDirectory?: string | null);
     listUnansweredOwnerCallEpochSecondsBySessionName: (transcriptPathBySessionName: Map<string, string>) => Promise<Map<string, number>>;
+    listUnansweredOwnerCallsBySessionName: (transcriptPathBySessionName: Map<string, string>) => Promise<Map<string, UnansweredOwnerCall[]>>;
+    private scanTranscript;
+    private resolveReplyEpochMs;
     private findUnansweredOwnerCallEpochMs;
     private readOwnerReplyMarkerEpochMs;
+    private isCallDeliveredToOwner;
     private isCallSuppressedUndelivered;
     private isCandidateCallDelivered;
     private readMarkerEpochMs;

package/types/adapter/repositories/TranscriptOwnerCallStatusProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TranscriptOwnerCallStatusProvider.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kEAAkE,CAAC;AA6F3G,eAAO,MAAM,4BAA4B,GAAI,QAAQ,MAAM,KAAG,MAAM,EAMtD,CAAC;AA4Cf,qBAAa,iCAAkC,YAAW,uBAAuB;IAK7E,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAJ5C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAW;gBAG/C,eAAe,EAAE,MAAM,GAAG,IAAI,EACb,yBAAyB,GAAE,MAAM,GAAG,IAAW;IAQlE,gDAAgD,GAC9C,6BAA6B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB7B;IAEF,OAAO,CAAC,8BAA8B,CAqFpC;IAOF,OAAO,CAAC,2BAA2B,CAGyC;IAS5E,OAAO,CAAC,2BAA2B,CAgBjC;IAEF,OAAO,CAAC,wBAAwB,CAoB9B;IAEF,OAAO,CAAC,iBAAiB,CA4BvB;CACH"}
+{"version":3,"file":"TranscriptOwnerCallStatusProvider.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kEAAkE,CAAC;AAC3G,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAwGhF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,MAAM,KAAG,MAAM,EAMtD,CAAC;AA4Cf,qBAAa,iCAAkC,YAAW,uBAAuB;IAK7E,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAJ5C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAW;gBAG/C,eAAe,EAAE,MAAM,GAAG,IAAI,EACb,yBAAyB,GAAE,MAAM,GAAG,IAAW;IAQlE,gDAAgD,GAC9C,6BAA6B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB7B;IAEF,qCAAqC,GACnC,6BAA6B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC,CAqC5C;IAEF,OAAO,CAAC,cAAc,CA6DpB;IAEF,OAAO,CAAC,mBAAmB,CAUzB;IAEF,OAAO,CAAC,8BAA8B,CAiCpC;IAOF,OAAO,CAAC,2BAA2B,CAGyC;IAS5E,OAAO,CAAC,sBAAsB,CAW5B;IAEF,OAAO,CAAC,2BAA2B,CAgBjC;IAEF,OAAO,CAAC,wBAAwB,CAoB9B;IAEF,OAAO,CAAC,iBAAiB,CA4BvB;CACH"}

package/types/domain/entities/UnansweredOwnerCall.d.ts

@@ -0,0 +1,5 @@
+export type UnansweredOwnerCall = {
+    calledAt: string;
+    body: string;
+};
+//# sourceMappingURL=UnansweredOwnerCall.d.ts.map

package/types/domain/entities/UnansweredOwnerCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnansweredOwnerCall.d.ts","sourceRoot":"","sources":["../../../src/domain/entities/UnansweredOwnerCall.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}