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

package/src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.test.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import { Issue } from '../../../domain/entities/Issue';
 import { FieldOption, Project } from '../../../domain/entities/Project';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
 
 const ASSIGNEE = 'owner-login';
 const CONSOLE_BASE_URL = 'https://console.example.test';
@@ -98,22 +99,124 @@ describe('writeInTmuxByHumanData', () => {
 
   const file = (name: string): string => path.join(outDir, name);
 
-  it('writes the four per-project files and the four index files', () => {
+  it('writes the five per-project files and the five index files', () => {
     writeInTmuxByHumanData(baseParams(outDir));
     for (const name of [
       'demo.json',
       'demo.v2.json',
       'demo.v3.json',
       'demo.v4.json',
+      'demo.v5.json',
       'index.json',
       'index.v2.json',
       'index.v3.json',
       'index.v4.json',
+      'index.v5.json',
     ]) {
       expect(fs.existsSync(file(name))).toBe(true);
     }
   });
 
+  it('writes the v5 shape carrying the unanswered calls of the session', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      unansweredCallsByTmuxSessionName: new Map([
+        [
+          toTmuxSessionName('https://github.com/demo/repo/issues/1'),
+          [
+            {
+              calledAt: '2026-08-13T10:14:00.000Z',
+              body: 'Please decide whether to merge the release branch',
+            },
+          ],
+        ],
+      ]),
+    });
+
+    expect(readJson(file('demo.v5.json'))).toEqual({
+      version: 5,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl: `${CONSOLE_BASE_URL}/projects/demo?k=${CONSOLE_TOKEN}`,
+      newIssueUrl: `https://github.com/demo-org/demo-repo/issues/new?assignees=${ASSIGNEE}`,
+      groups: [
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+              unansweredCalls: [
+                {
+                  calledAt: '2026-08-13T10:14:00.000Z',
+                  body: 'Please decide whether to merge the release branch',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('writes an empty unansweredCalls array when no call is supplied', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v5.json'))).toMatchObject({
+      groups: [
+        {
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              unansweredCalls: [],
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('points the v5 index entry at the v5 document of each project', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('index.v5.json'))).toEqual({
+      version: 5,
+      projects: [
+        {
+          name: 'demo',
+          path: `/${path.basename(outDir)}/demo.v5.json?k=${CONSOLE_TOKEN}`,
+        },
+      ],
+    });
+  });
+
+  it('keeps the v4 document free of unanswered call data when calls are supplied', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      unansweredCallsByTmuxSessionName: new Map([
+        [
+          toTmuxSessionName('https://github.com/demo/repo/issues/1'),
+          [{ calledAt: '2026-08-13T10:14:00.000Z', body: 'first call body' }],
+        ],
+      ]),
+    });
+
+    expect(readJson(file('demo.v4.json'))).toEqual({
+      version: 4,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl: `${CONSOLE_BASE_URL}/projects/demo?k=${CONSOLE_TOKEN}`,
+      newIssueUrl: `https://github.com/demo-org/demo-repo/issues/new?assignees=${ASSIGNEE}`,
+      groups: [
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+            },
+          ],
+        },
+      ],
+    });
+  });
+
   it('writes pretty-printed JSON ending with a trailing newline', () => {
     writeInTmuxByHumanData(baseParams(outDir));
     const raw = fs.readFileSync(file('demo.json'), 'utf8');

package/src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.ts

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import type { Issue } from '../../../domain/entities/Issue';
 import type { Project } from '../../../domain/entities/Project';
+import type { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
 import {
   GenerateInTmuxByHumanDataUseCase,
   InTmuxByHumanData,
@@ -19,6 +20,7 @@ export type InTmuxByHumanDataWriterParams = {
   newIssueRepo?: string | null | undefined;
   project: Project;
   issues: Issue[];
+  unansweredCallsByTmuxSessionName?: Map<string, UnansweredOwnerCall[]>;
   now: Date;
 };
 
@@ -45,6 +47,7 @@ export const writeInTmuxByHumanData = (
     newIssueRepo,
     project,
     issues,
+    unansweredCallsByTmuxSessionName,
     now,
   } = params;
   if (!inTmuxDataOutputDir || !pjcode || !assigneeLogin) {
@@ -61,6 +64,9 @@ export const writeInTmuxByHumanData = (
     newIssueRepo: newIssueRepo ?? undefined,
     consoleBaseUrl: inTmuxConsoleBaseUrl ?? null,
     consoleToken: inTmuxConsoleToken ?? null,
+    unansweredCallsByTmuxSessionName:
+      unansweredCallsByTmuxSessionName ??
+      new Map<string, UnansweredOwnerCall[]>(),
     now,
   });
 
@@ -78,6 +84,12 @@ export const writeInTmuxByHumanData = (
       data.v4,
     );
   }
+  if (data.v5) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v5.json`),
+      data.v5,
+    );
+  }
 
   if (!inTmuxProjectOrder || inTmuxProjectOrder.length === 0) {
     return;
@@ -105,5 +117,12 @@ export const writeInTmuxByHumanData = (
         path: `/${outputDirBasename}/${name}.v4.json?k=${inTmuxConsoleToken}`,
       })),
     });
+    writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v5.json'), {
+      version: 5,
+      projects: presentProjects.map((name) => ({
+        name,
+        path: `/${outputDirBasename}/${name}.v5.json?k=${inTmuxConsoleToken}`,
+      })),
+    });
   }
 };

package/src/adapter/entry-points/handlers/resolveUnansweredOwnerCalls.test.ts

@@ -0,0 +1,111 @@
+import { resolveUnansweredOwnerCallsByTmuxSessionName } from './resolveUnansweredOwnerCalls';
+import { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
+import { InteractiveLiveSession } from '../../../domain/entities/InteractiveLiveSession';
+import { LiveSessionProcessSnapshot } from '../../../domain/entities/LiveSessionProcessSnapshot';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+
+const ISSUE_URL = 'https://github.com/demo/repo/issues/1';
+const TMUX_SESSION_NAME = toTmuxSessionName(ISSUE_URL);
+const CONFIG_DIR = '/home/agent/.claude';
+const SESSION_ID = 'session-id-1';
+
+const snapshotWithSession = (): LiveSessionProcessSnapshot => ({
+  sessions: [{ sessionName: TMUX_SESSION_NAME, panePids: [100] }],
+  processes: [
+    {
+      pid: 100,
+      ppid: 1,
+      commandLine: `claude ${ISSUE_URL}`,
+      sessionId: SESSION_ID,
+      currentSessionId: SESSION_ID,
+      configDir: CONFIG_DIR,
+    },
+  ],
+});
+
+describe('resolveUnansweredOwnerCallsByTmuxSessionName', () => {
+  it('asks the call provider for the transcripts of the live interactive sessions and returns what it reports', async () => {
+    const call: UnansweredOwnerCall = {
+      calledAt: '2026-08-13T10:14:00.000Z',
+      body: 'Please decide whether to merge the release branch',
+    };
+    const requestedTranscriptPaths: Map<string, string>[] = [];
+    const resolvedSessions: InteractiveLiveSession[][] = [];
+
+    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
+      liveSessionProcessSnapshotProvider: {
+        getSnapshot: async () => snapshotWithSession(),
+      },
+      interactiveLiveSessionTranscriptResolver: {
+        resolveTranscriptPaths: (sessions) => {
+          resolvedSessions.push(sessions);
+          return new Map(
+            sessions.map((session) => [
+              session.sessionName,
+              `/transcripts/${session.sessionId}.jsonl`,
+            ]),
+          );
+        },
+      },
+      unansweredOwnerCallListProvider: {
+        listUnansweredOwnerCallsBySessionName: async (
+          transcriptPathBySessionName,
+        ) => {
+          requestedTranscriptPaths.push(transcriptPathBySessionName);
+          return new Map([[TMUX_SESSION_NAME, [call]]]);
+        },
+      },
+    });
+
+    expect(resolvedSessions[0]?.map((session) => session.sessionName)).toEqual([
+      TMUX_SESSION_NAME,
+    ]);
+    expect(requestedTranscriptPaths[0]?.get(TMUX_SESSION_NAME)).toBe(
+      `/transcripts/${SESSION_ID}.jsonl`,
+    );
+    expect(result.get(TMUX_SESSION_NAME)).toEqual([call]);
+  });
+
+  it('keys the returned calls by the tmux session name the reconciler derives from the issue url', async () => {
+    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
+      liveSessionProcessSnapshotProvider: {
+        getSnapshot: async () => snapshotWithSession(),
+      },
+      interactiveLiveSessionTranscriptResolver: {
+        resolveTranscriptPaths: (sessions) =>
+          new Map(
+            sessions.map((session) => [session.sessionName, '/transcript']),
+          ),
+      },
+      unansweredOwnerCallListProvider: {
+        listUnansweredOwnerCallsBySessionName: async (
+          transcriptPathBySessionName,
+        ) =>
+          new Map(
+            [...transcriptPathBySessionName.keys()].map((sessionName) => [
+              sessionName,
+              [{ calledAt: '2026-08-13T10:14:00.000Z', body: 'body' }],
+            ]),
+          ),
+      },
+    });
+
+    expect([...result.keys()]).toEqual([toTmuxSessionName(ISSUE_URL)]);
+  });
+
+  it('returns nothing when no live session exposes a transcript', async () => {
+    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
+      liveSessionProcessSnapshotProvider: {
+        getSnapshot: async () => ({ sessions: [], processes: [] }),
+      },
+      interactiveLiveSessionTranscriptResolver: {
+        resolveTranscriptPaths: () => new Map(),
+      },
+      unansweredOwnerCallListProvider: {
+        listUnansweredOwnerCallsBySessionName: async () => new Map(),
+      },
+    });
+
+    expect(result.size).toBe(0);
+  });
+});

package/src/adapter/entry-points/handlers/resolveUnansweredOwnerCalls.ts

@@ -0,0 +1,33 @@
+import { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
+import { InteractiveLiveSession } from '../../../domain/entities/InteractiveLiveSession';
+import { ResolveInteractiveLiveSessionsUseCase } from '../../../domain/usecases/ResolveInteractiveLiveSessionsUseCase';
+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 const resolveUnansweredOwnerCallsByTmuxSessionName = async (
+  params: ResolveUnansweredOwnerCallsParams,
+): Promise<Map<string, UnansweredOwnerCall[]>> => {
+  const snapshot =
+    await params.liveSessionProcessSnapshotProvider.getSnapshot();
+  const interactiveSessions: InteractiveLiveSession[] =
+    new ResolveInteractiveLiveSessionsUseCase().resolve(snapshot);
+  const transcriptPathBySessionName =
+    params.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
+      interactiveSessions,
+    );
+  return params.unansweredOwnerCallListProvider.listUnansweredOwnerCallsBySessionName(
+    transcriptPathBySessionName,
+  );
+};

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', () => {