github-issue-tower-defence-management 1.122.3 → 1.122.4

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

@@ -2,6 +2,10 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
+import {
+  SubAgentProcess,
+  SubAgentProcessLister,
+} from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
 import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
 
@@ -70,6 +74,14 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
   const createResolver = (): SubAgentTranscriptDirectoryResolver =>
     new FileSystemSubAgentTranscriptDirectoryResolver(rootDirectory);
 
+  const processListerWith = (
+    processes: SubAgentProcess[],
+  ): SubAgentProcessLister => ({
+    listProcesses: async () => processes,
+  });
+
+  const emptyProcessLister = (): SubAgentProcessLister => processListerWith([]);
+
   const runningEntries = (startTimestamp: string): object[] => [
     { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
     {
@@ -251,6 +263,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -260,7 +273,12 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
 
     expect(result.get(sessionName)).toEqual([
-      { label: 'agent-aaa111', silentSeconds: 120, runningSeconds: 900 },
+      {
+        label: 'agent-aaa111',
+        silentSeconds: 120,
+        runningSeconds: 900,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 
@@ -274,6 +292,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -295,6 +314,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -316,6 +336,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -337,6 +358,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -358,6 +380,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -379,6 +402,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -400,6 +424,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -421,6 +446,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -430,7 +456,12 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
 
     expect(result.get(sessionName)).toEqual([
-      { label: 'agent-pending', silentSeconds: 600, runningSeconds: 900 },
+      {
+        label: 'agent-pending',
+        silentSeconds: 600,
+        runningSeconds: 900,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 
@@ -445,6 +476,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -458,6 +490,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
         label: 'agent-longstall',
         silentSeconds: fourDaysSeconds,
         runningSeconds: fourDaysSeconds,
+        waitingOnExternalProcess: false,
       },
     ]);
   });
@@ -480,6 +513,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     fs.symlinkSync(targetPath, path.join(dir, 'agent-link1.jsonl'));
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -489,7 +523,12 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
 
     expect(result.get(sessionName)).toEqual([
-      { label: 'agent-link1', silentSeconds: 60, runningSeconds: 600 },
+      {
+        label: 'agent-link1',
+        silentSeconds: 60,
+        runningSeconds: 600,
+        waitingOnExternalProcess: false,
+      },
     ]);
     fs.rmSync(targetDir, { force: true, recursive: true });
   });
@@ -497,6 +536,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
   it('returns an empty map when the resolver returns null', async () => {
     const repository = new TranscriptSessionSubAgentActivityRepository(
       { resolveSubAgentsDirectory: () => null },
+      emptyProcessLister(),
       now,
     );
 
@@ -511,6 +551,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
   it('ignores a session whose subagents directory does not exist', async () => {
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -538,6 +579,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -559,6 +601,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -568,7 +611,12 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
 
     expect(result.get(sessionName)).toEqual([
-      { label: 'agent-future', silentSeconds: 0, runningSeconds: 0 },
+      {
+        label: 'agent-future',
+        silentSeconds: 0,
+        runningSeconds: 0,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 
@@ -604,6 +652,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
 
     const repository = new TranscriptSessionSubAgentActivityRepository(
       new FileSystemSubAgentTranscriptDirectoryResolver(projectsRoot),
+      emptyProcessLister(),
       now,
     );
 
@@ -617,6 +666,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
         label: 'agent-afcbe335fdbec0a28',
         silentSeconds: 120,
         runningSeconds: 900,
+        waitingOnExternalProcess: false,
       },
     ]);
   });
@@ -638,6 +688,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
+      emptyProcessLister(),
       now,
     );
 
@@ -651,7 +702,148 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
         label: 'agent-stalledold',
         silentSeconds: twoDaysSeconds,
         runningSeconds: twoDaysSeconds,
+        waitingOnExternalProcess: false,
       },
     ]);
   });
+
+  describe('external-wait classification from the pending tool command', () => {
+    const CI_WATCH_COMMAND =
+      'gh pr checks 123 --watch -i 60 -R owner/repo 2>&1 | tail -5';
+
+    const pendingCommandEntries = (
+      startTimestamp: string,
+      command: string,
+    ): object[] => [
+      { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
+      {
+        type: 'assistant',
+        timestamp: startTimestamp,
+        message: {
+          role: 'assistant',
+          stop_reason: 'tool_use',
+          content: [{ type: 'tool_use', name: 'Bash', input: { command } }],
+        },
+      },
+    ];
+
+    it('classifies a sub-agent as waiting when its pending tool command matches a live process', async () => {
+      const sessionName = 'https_//github_com/owner/repo/issues/9';
+      writeAgentTranscript(
+        sessionName,
+        'ciwait',
+        pendingCommandEntries('2026-06-27T11:45:00.000Z', CI_WATCH_COMMAND),
+        nowEpochSeconds - 600,
+      );
+      const repository = new TranscriptSessionSubAgentActivityRepository(
+        createResolver(),
+        processListerWith([
+          {
+            commandLine: `/bin/bash -c ${CI_WATCH_COMMAND}`,
+            elapsedSeconds: 600,
+          },
+        ]),
+        now,
+      );
+
+      const result = await repository.listSubAgentActivitiesBySessionName(
+        [sessionName],
+        transcriptMapFor([sessionName]),
+      );
+
+      expect(result.get(sessionName)).toEqual([
+        {
+          label: 'agent-ciwait',
+          silentSeconds: 600,
+          runningSeconds: 900,
+          waitingOnExternalProcess: true,
+        },
+      ]);
+    });
+
+    it('classifies a sub-agent as hung when no live process matches its pending tool command', async () => {
+      const sessionName = 'https_//github_com/owner/repo/issues/9';
+      writeAgentTranscript(
+        sessionName,
+        'dead',
+        pendingCommandEntries('2026-06-27T11:45:00.000Z', CI_WATCH_COMMAND),
+        nowEpochSeconds - 600,
+      );
+      const repository = new TranscriptSessionSubAgentActivityRepository(
+        createResolver(),
+        processListerWith([
+          { commandLine: 'node unrelated-server.js', elapsedSeconds: 5000 },
+        ]),
+        now,
+      );
+
+      const result = await repository.listSubAgentActivitiesBySessionName(
+        [sessionName],
+        transcriptMapFor([sessionName]),
+      );
+
+      expect(result.get(sessionName)).toEqual([
+        {
+          label: 'agent-dead',
+          silentSeconds: 600,
+          runningSeconds: 900,
+          waitingOnExternalProcess: false,
+        },
+      ]);
+    });
+
+    it('classifies a sub-agent as hung when its pending tool call carries no command string', async () => {
+      const sessionName = 'https_//github_com/owner/repo/issues/9';
+      writeAgentTranscript(
+        sessionName,
+        'nocmd',
+        pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
+        nowEpochSeconds - 600,
+      );
+      const repository = new TranscriptSessionSubAgentActivityRepository(
+        createResolver(),
+        processListerWith([
+          { commandLine: 'any process at all', elapsedSeconds: 1 },
+        ]),
+        now,
+      );
+
+      const result = await repository.listSubAgentActivitiesBySessionName(
+        [sessionName],
+        transcriptMapFor([sessionName]),
+      );
+
+      expect(result.get(sessionName)?.[0]?.waitingOnExternalProcess).toBe(
+        false,
+      );
+    });
+
+    it('matches on the whitespace-normalized first 60 characters of a long multi-line command', async () => {
+      const sessionName = 'https_//github_com/owner/repo/issues/9';
+      const longCommand =
+        'OWNER=owner; REPO=repo; PR=123\n  SHA=$(gh api repos/$OWNER/$REPO/pulls/$PR --jq .head.sha)\n  sleep 600';
+      writeAgentTranscript(
+        sessionName,
+        'longcmd',
+        pendingCommandEntries('2026-06-27T11:45:00.000Z', longCommand),
+        nowEpochSeconds - 600,
+      );
+      const normalizedProcessLine =
+        'bash -c OWNER=owner; REPO=repo; PR=123 SHA=$(gh api repos/$OWNER/$REPO/pulls/$PR --jq .head.sha) sleep 600';
+      const repository = new TranscriptSessionSubAgentActivityRepository(
+        createResolver(),
+        processListerWith([
+          { commandLine: normalizedProcessLine, elapsedSeconds: 600 },
+        ]),
+        now,
+      );
+
+      const result = await repository.listSubAgentActivitiesBySessionName(
+        [sessionName],
+        transcriptMapFor([sessionName]),
+      );
+
+      expect(result.get(sessionName)?.[0]?.waitingOnExternalProcess).toBe(true);
+    });
+  });
 });

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
 import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
+import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -23,9 +24,18 @@ const parseEpochSeconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : Math.floor(parsed / 1000);
 };
 
+const PENDING_TOOL_COMMAND_FRAGMENT_LENGTH = 60;
+
+export const normalizeCommandFragment = (command: string): string =>
+  command
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, PENDING_TOOL_COMMAND_FRAGMENT_LENGTH);
+
 type ParsedTranscript = {
   firstEntryEpochSeconds: number | null;
   lastEntryIndicatesCompletion: boolean;
+  pendingToolCommands: string[];
 };
 
 const readContentBlocks = (
@@ -65,9 +75,33 @@ const entryIndicatesCompletion = (entry: Record<string, unknown>): boolean => {
   return false;
 };
 
+const entryPendingToolCommands = (entry: Record<string, unknown>): string[] => {
+  const type = readString(entry, 'type');
+  const message = entry.message;
+  if (type !== 'assistant' || !isRecord(message)) {
+    return [];
+  }
+  const commands: string[] = [];
+  for (const block of readContentBlocks(message)) {
+    if (readString(block, 'type') !== 'tool_use') {
+      continue;
+    }
+    const input = block.input;
+    if (!isRecord(input)) {
+      continue;
+    }
+    const command = readString(input, 'command');
+    if (command !== null && command.trim().length > 0) {
+      commands.push(command);
+    }
+  }
+  return commands;
+};
+
 const parseTranscript = (content: string): ParsedTranscript => {
   let firstEntryEpochSeconds: number | null = null;
   let lastEntryIndicatesCompletion = false;
+  let pendingToolCommands: string[] = [];
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
     if (trimmed.length === 0) {
@@ -88,9 +122,14 @@ const parseTranscript = (content: string): ParsedTranscript => {
     }
     if (isRecord(parsed.message)) {
       lastEntryIndicatesCompletion = entryIndicatesCompletion(parsed);
+      pendingToolCommands = entryPendingToolCommands(parsed);
     }
   }
-  return { firstEntryEpochSeconds, lastEntryIndicatesCompletion };
+  return {
+    firstEntryEpochSeconds,
+    lastEntryIndicatesCompletion,
+    pendingToolCommands,
+  };
 };
 
 const clampToZero = (value: number): number => (value > 0 ? value : 0);
@@ -98,6 +137,7 @@ const clampToZero = (value: number): number => (value > 0 ? value : 0);
 export class TranscriptSessionSubAgentActivityRepository implements SessionSubAgentActivityRepository {
   constructor(
     private readonly directoryResolver: SubAgentTranscriptDirectoryResolver,
+    private readonly processLister: SubAgentProcessLister,
     private readonly now: Date,
   ) {}
 
@@ -107,6 +147,16 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
   ): Promise<Map<string, SubAgentActivity[]>> => {
     const result = new Map<string, SubAgentActivity[]>();
     const nowEpochSeconds = Math.floor(this.now.getTime() / 1000);
+    let normalizedProcessCommandLines: string[] | null = null;
+    const loadNormalizedProcessCommandLines = async (): Promise<string[]> => {
+      if (normalizedProcessCommandLines === null) {
+        const processes = await this.processLister.listProcesses();
+        normalizedProcessCommandLines = processes.map((process) =>
+          process.commandLine.replace(/\s+/g, ' ').trim(),
+        );
+      }
+      return normalizedProcessCommandLines;
+    };
     for (const sessionName of sessionNames) {
       const mainTranscriptPath =
         transcriptPathBySessionName.get(sessionName) ?? null;
@@ -117,7 +167,11 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       if (directory === null) {
         continue;
       }
-      const activities = this.collectActivities(directory, nowEpochSeconds);
+      const activities = await this.collectActivities(
+        directory,
+        nowEpochSeconds,
+        loadNormalizedProcessCommandLines,
+      );
       if (activities.length > 0) {
         result.set(sessionName, activities);
       }
@@ -125,10 +179,11 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return result;
   };
 
-  private collectActivities = (
+  private collectActivities = async (
     directory: string,
     nowEpochSeconds: number,
-  ): SubAgentActivity[] => {
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<SubAgentActivity[]> => {
     let entries: fs.Dirent[];
     try {
       entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -142,7 +197,12 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
         continue;
       }
       const filePath = path.join(directory, fileName);
-      const activity = this.toActivity(filePath, fileName, nowEpochSeconds);
+      const activity = await this.toActivity(
+        filePath,
+        fileName,
+        nowEpochSeconds,
+        loadNormalizedProcessCommandLines,
+      );
       if (activity !== null) {
         activities.push(activity);
       }
@@ -150,11 +210,12 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return activities;
   };
 
-  private toActivity = (
+  private toActivity = async (
     filePath: string,
     fileName: string,
     nowEpochSeconds: number,
-  ): SubAgentActivity | null => {
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<SubAgentActivity | null> => {
     let content: string;
     let stats: fs.Stats;
     try {
@@ -178,6 +239,29 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       label: fileName.replace(/\.jsonl$/, ''),
       silentSeconds,
       runningSeconds,
+      waitingOnExternalProcess: await this.hasLiveMatchingProcess(
+        transcript.pendingToolCommands,
+        loadNormalizedProcessCommandLines,
+      ),
     };
   };
+
+  private hasLiveMatchingProcess = async (
+    pendingToolCommands: string[],
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<boolean> => {
+    if (pendingToolCommands.length === 0) {
+      return false;
+    }
+    const fragments = pendingToolCommands
+      .map(normalizeCommandFragment)
+      .filter((fragment) => fragment.length > 0);
+    if (fragments.length === 0) {
+      return false;
+    }
+    const processCommandLines = await loadNormalizedProcessCommandLines();
+    return fragments.some((fragment) =>
+      processCommandLines.some((commandLine) => commandLine.includes(fragment)),
+    );
+  };
 }

package/src/domain/entities/LiveSessionActivitySnapshot.ts

@@ -2,6 +2,7 @@ export type SubAgentActivity = {
   label: string;
   silentSeconds: number;
   runningSeconds: number;
+  waitingOnExternalProcess: boolean;
 };
 
 export type LiveSessionActivitySnapshot = {