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

package/src/adapter/repositories/FileSystemSilentSessionCandidateStateRepository.ts

@@ -8,10 +8,17 @@ type StoredCandidateEntry = {
   recordedEpochSeconds: number;
 };
 
+type StoredAnnouncedRunningEntry = {
+  sessionName: string;
+  labels: string[];
+  recordedEpochSeconds: number;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
 export const DEFAULT_STATE_RETENTION_WINDOW_SECONDS = 60 * 60;
+export const ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS = 24 * 60 * 60;
 
 const defaultStateFilePath = (): string => {
   const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
@@ -31,7 +38,7 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
     const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
     const oldestAllowedEpochSeconds =
       nowEpochSeconds - params.recencyWindowSeconds;
-    const entries = this.readEntries();
+    const entries = this.readCandidateEntries();
     const recentSessionNames = new Set<string>();
     for (const entry of entries) {
       if (entry.recordedEpochSeconds >= oldestAllowedEpochSeconds) {
@@ -50,7 +57,7 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
       recordedEpochSeconds - this.retentionWindowSeconds;
     const currentSessionNames = new Set(params.sessionNames);
     const mergedBySessionName = new Map<string, StoredCandidateEntry>();
-    for (const entry of this.readEntries()) {
+    for (const entry of this.readCandidateEntries()) {
       if (
         entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
         !currentSessionNames.has(entry.sessionName)
@@ -64,26 +71,65 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
         recordedEpochSeconds,
       });
     }
-    this.writeEntries(Array.from(mergedBySessionName.values()));
+    this.writeState(
+      Array.from(mergedBySessionName.values()),
+      this.readAnnouncedRunningEntries(),
+    );
+  };
+
+  loadAnnouncedRunningSubAgentLabels = async (params: {
+    sessionName: string;
+  }): Promise<Set<string>> => {
+    const entry = this.readAnnouncedRunningEntries().find(
+      (candidate) => candidate.sessionName === params.sessionName,
+    );
+    return new Set(entry?.labels ?? []);
+  };
+
+  saveAnnouncedRunningSubAgentLabels = async (params: {
+    sessionName: string;
+    labels: string[];
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      recordedEpochSeconds - ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS;
+    const retainedEntries = this.readAnnouncedRunningEntries().filter(
+      (entry) =>
+        entry.sessionName !== params.sessionName &&
+        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds,
+    );
+    if (params.labels.length > 0) {
+      retainedEntries.push({
+        sessionName: params.sessionName,
+        labels: params.labels,
+        recordedEpochSeconds,
+      });
+    }
+    this.writeState(this.readCandidateEntries(), retainedEntries);
   };
 
-  private readEntries = (): StoredCandidateEntry[] => {
+  private readState = (): Record<string, unknown> => {
     let raw: string;
     try {
       raw = fs.readFileSync(this.stateFilePath, 'utf8');
     } catch {
-      return [];
+      return {};
     }
     let parsed: unknown;
     try {
       parsed = JSON.parse(raw);
     } catch {
-      return [];
+      return {};
     }
     if (!isRecord(parsed)) {
-      return [];
+      return {};
     }
-    const storedEntries = parsed.candidates;
+    return parsed;
+  };
+
+  private readCandidateEntries = (): StoredCandidateEntry[] => {
+    const storedEntries = this.readState().candidates;
     if (!Array.isArray(storedEntries)) {
       return [];
     }
@@ -105,11 +151,49 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
     return entries;
   };
 
-  private writeEntries = (entries: StoredCandidateEntry[]): void => {
+  private readAnnouncedRunningEntries = (): StoredAnnouncedRunningEntry[] => {
+    const storedEntries = this.readState().announcedRunningSubAgents;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredAnnouncedRunningEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      const storedLabels = storedEntry.labels;
+      if (
+        typeof sessionName !== 'string' ||
+        typeof recordedEpochSeconds !== 'number' ||
+        !Number.isFinite(recordedEpochSeconds) ||
+        !Array.isArray(storedLabels)
+      ) {
+        continue;
+      }
+      const labels = storedLabels.filter(
+        (label): label is string => typeof label === 'string',
+      );
+      if (labels.length !== storedLabels.length) {
+        continue;
+      }
+      entries.push({ sessionName, labels, recordedEpochSeconds });
+    }
+    return entries;
+  };
+
+  private writeState = (
+    candidates: StoredCandidateEntry[],
+    announcedRunningSubAgents: StoredAnnouncedRunningEntry[],
+  ): void => {
     const directory = path.dirname(this.stateFilePath);
     fs.mkdirSync(directory, { recursive: true });
     const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
-    fs.writeFileSync(temporaryPath, JSON.stringify({ candidates: entries }));
+    fs.writeFileSync(
+      temporaryPath,
+      JSON.stringify({ candidates, announcedRunningSubAgents }),
+    );
     fs.renameSync(temporaryPath, this.stateFilePath);
   };
 }

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

@@ -54,7 +54,12 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
     );
     const result = await repository.listSubAgentActivitiesBySessionName(['s1']);
     expect(result.get('s1')).toEqual([
-      { label: 'task-a', silentSeconds: 180, runningSeconds: 1200 },
+      {
+        label: 'task-a',
+        silentSeconds: 180,
+        runningSeconds: 1200,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 
@@ -78,7 +83,12 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
     );
     const result = await repository.listSubAgentActivitiesBySessionName(['s1']);
     expect(result.get('s1')).toEqual([
-      { label: 's1', silentSeconds: 0, runningSeconds: 30 },
+      {
+        label: 's1',
+        silentSeconds: 0,
+        runningSeconds: 30,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 

package/src/adapter/repositories/ProcessListSessionSubAgentActivityRepository.ts

@@ -43,6 +43,7 @@ export class ProcessListSessionSubAgentActivityRepository implements SessionSubA
         label,
         silentSeconds: this.silentSecondsResolver.resolveSilentSeconds(label),
         runningSeconds: process.elapsedSeconds,
+        waitingOnExternalProcess: false,
       };
       const existing = result.get(sessionName);
       if (existing === undefined) {

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