github-issue-tower-defence-management 1.110.1 → 1.111.1

package/src/adapter/repositories/ProcFsProcessEnvironReader.ts

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+
+/**
+ * Reads a process environment from the Linux procfs (`/proc/<pid>/environ`),
+ * where entries are NUL-separated `KEY=value` pairs. Returns null when the
+ * environment cannot be read (the process has exited or is not accessible).
+ */
+export class ProcFsProcessEnvironReader implements ProcessEnvironReader {
+  constructor(private readonly procDirectory: string = '/proc') {}
+
+  readEnviron = (pid: number): Record<string, string> | null => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(
+        path.join(this.procDirectory, String(pid), 'environ'),
+        'utf8',
+      );
+    } catch {
+      return null;
+    }
+    const environ: Record<string, string> = {};
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex === -1) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ[key] = value;
+    }
+    return environ;
+  };
+}

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

@@ -16,14 +16,14 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     fs.rmSync(rootDirectory, { force: true, recursive: true });
   });
 
-  const writeTranscript = (sessionName: string, lines: object[]): void => {
-    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
+  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 => ({
@@ -63,141 +63,104 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     },
   });
 
+  const sessionName = 'workbench';
+
   it('reports a session as waiting when the last owner call is newer than the last owner reply', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       ownerReply('2026-06-27T10:00:00.000Z'),
       assistantWithMarker('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });
 
   it('does not report a session as waiting when a later owner reply followed the call', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T10:00:00.000Z'),
       ownerReply('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(false);
   });
 
   it('compares full datetimes rather than only the time of day', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T23:00:00.000Z'),
       ownerReply('2026-06-28T01:00:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(false);
   });
 
   it('treats tool results as not being owner replies', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T10:00:00.000Z'),
       toolResult('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });
 
   it('does not report a session that never raised an owner call', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantPlain('2026-06-27T10:00:00.000Z'),
       ownerReply('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
-
-    expect(result.has(sessionName)).toBe(false);
-  });
-
-  it('returns an empty set when the root directory is null', async () => {
-    const provider = new TranscriptOwnerCallStatusProvider(
-      null,
-      '<<OWNER_CALL>>',
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
     );
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'https_//github_com/owner/repo/issues/9',
-    ]);
-
-    expect(result.size).toBe(0);
+    expect(result.has(sessionName)).toBe(false);
   });
 
   it('returns an empty set when the marker is null', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       ownerReply('2026-06-27T10:00:00.000Z'),
       assistantWithMarker('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(rootDirectory, null);
+    const provider = new TranscriptOwnerCallStatusProvider(null);
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.size).toBe(0);
   });
 
   it('ignores a session whose transcript file is missing', async () => {
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'https_//github_com/owner/repo/issues/9',
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, path.join(rootDirectory, 'missing.jsonl')]]),
+    );
 
     expect(result.size).toBe(0);
   });
 
   it('ignores malformed transcript lines', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
-    const filePath = path.join(rootDirectory, fileName);
+    const filePath = path.join(rootDirectory, 'workbench.jsonl');
     fs.writeFileSync(
       filePath,
       [
@@ -206,14 +169,31 @@ describe('TranscriptOwnerCallStatusProvider', () => {
       ].join('\n'),
       'utf8',
     );
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, filePath]]),
     );
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
+    expect(result.has(sessionName)).toBe(true);
+  });
+
+  it('uses the canonical call-to-user marker string', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Please decide <call-to-user>' }],
+        },
+      },
     ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -1,5 +1,4 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -51,24 +50,18 @@ const hasOwnerTextReply = (content: unknown): boolean => {
 };
 
 export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
-  constructor(
-    private readonly rootDirectory: string | null,
-    private readonly ownerCallMarker: string | null,
-  ) {}
+  constructor(private readonly ownerCallMarker: string | null) {}
 
   listSessionNamesWithUnansweredOwnerCall = async (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ): Promise<Set<string>> => {
     const waiting = new Set<string>();
-    if (
-      this.rootDirectory === null ||
-      this.ownerCallMarker === null ||
-      this.ownerCallMarker.length === 0
-    ) {
+    if (this.ownerCallMarker === null || this.ownerCallMarker.length === 0) {
       return waiting;
     }
-    for (const sessionName of sessionNames) {
-      if (this.isWaitingForOwnerReply(sessionName, this.ownerCallMarker)) {
+    const marker = this.ownerCallMarker;
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      if (this.isWaitingForOwnerReply(transcriptPath, marker)) {
         waiting.add(sessionName);
       }
     }
@@ -76,19 +69,12 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
   };
 
   private isWaitingForOwnerReply = (
-    sessionName: string,
+    transcriptPath: string,
     marker: string,
   ): boolean => {
-    if (this.rootDirectory === null) {
-      return false;
-    }
-    const filePath = path.join(
-      this.rootDirectory,
-      this.toTranscriptFileName(sessionName),
-    );
     let content: string;
     try {
-      content = fs.readFileSync(filePath, 'utf8');
+      content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
       return false;
     }
@@ -133,7 +119,4 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
       lastOwnerCallEpochMs > lastOwnerReplyEpochMs
     );
   };
-
-  private toTranscriptFileName = (sessionName: string): string =>
-    `${sessionName.replace(/\//g, '_')}.jsonl`;
 }

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

@@ -67,6 +67,15 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     },
   ];
 
+  const stopSequenceFinishedEntries = (startTimestamp: string): object[] => [
+    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
+    {
+      type: 'assistant',
+      timestamp: startTimestamp,
+      message: { role: 'assistant', stop_reason: 'stop_sequence' },
+    },
+  ];
+
   it('reports a running sub-agent with silent seconds from the file mtime and running seconds from the first entry', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     const startTimestamp = '2026-06-27T11:45:00.000Z';
@@ -110,6 +119,26 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     expect(result.size).toBe(0);
   });
 
+  it('excludes a finished sub-agent whose last entry stop_reason is stop_sequence', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeAgentTranscript(
+      sessionName,
+      'done2',
+      stopSequenceFinishedEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 30,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
   it('follows a symlinked transcript when computing silent seconds', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     const targetDir = fs.mkdtempSync(

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -126,7 +126,10 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       return null;
     }
     const transcript = parseTranscript(content);
-    if (transcript.lastStopReason === 'end_turn') {
+    if (
+      transcript.lastStopReason === 'end_turn' ||
+      transcript.lastStopReason === 'stop_sequence'
+    ) {
       return null;
     }
     const silentSeconds = clampToZero(

package/src/domain/entities/InteractiveLiveSession.ts

@@ -0,0 +1,5 @@
+export type InteractiveLiveSession = {
+  sessionName: string;
+  sessionId: string;
+  configDir: string;
+};

package/src/domain/entities/LiveSessionProcessSnapshot.ts

@@ -0,0 +1,17 @@
+export type LiveSessionPaneProcess = {
+  sessionName: string;
+  panePids: number[];
+};
+
+export type LiveSessionProcessInfo = {
+  pid: number;
+  ppid: number;
+  commandLine: string;
+  sessionId: string | null;
+  configDir: string | null;
+};
+
+export type LiveSessionProcessSnapshot = {
+  sessions: LiveSessionPaneProcess[];
+  processes: LiveSessionProcessInfo[];
+};