github-issue-tower-defence-management 1.122.11 → 1.122.12

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

@@ -3,7 +3,6 @@ import * as os from 'os';
 import * as path from 'path';
 import {
   DEFAULT_STATE_RETENTION_WINDOW_SECONDS,
-  ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS,
   FileSystemSilentSessionCandidateStateRepository,
 } from './FileSystemSilentSessionCandidateStateRepository';
 
@@ -142,7 +141,6 @@ describe('FileSystemSilentSessionCandidateStateRepository', () => {
           recordedEpochSeconds: Math.floor(secondSaveAt.getTime() / 1000),
         },
       ],
-      announcedRunningSubAgents: [],
     });
   });
 
@@ -201,224 +199,55 @@ describe('FileSystemSilentSessionCandidateStateRepository', () => {
     expect(DEFAULT_STATE_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
   });
 
-  describe('announced running sub-agent labels', () => {
-    it('round-trips saved announced labels so the next cycle reads them back', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-1', 'sub-process-2'],
-        now: new Date('2026-06-26T00:00:00Z'),
-      });
-      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-      });
-
-      expect(loaded).toEqual(new Set(['sub-process-1', 'sub-process-2']));
-    });
-
-    it('returns an empty set when no announcement has been recorded for the session', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-      });
-
-      expect(loaded).toEqual(new Set<string>());
-    });
-
-    it('replaces the previous announced labels of the same session', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-1'],
-        now: new Date('2026-06-26T00:00:00Z'),
-      });
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-2'],
-        now: new Date('2026-06-26T00:01:00Z'),
-      });
-      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-      });
-
-      expect(loaded).toEqual(new Set(['sub-process-2']));
-    });
-
-    it('removes the stored entry when saving an empty label set', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-1'],
-        now: new Date('2026-06-26T00:00:00Z'),
-      });
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: [],
-        now: new Date('2026-06-26T00:01:00Z'),
-      });
-
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
-          sessionName: sessionAlpha,
-        }),
-      ).toEqual(new Set<string>());
-      const persisted: unknown = JSON.parse(
-        fs.readFileSync(stateFilePath, 'utf8'),
-      );
-      expect(persisted).toEqual({
-        candidates: [],
-        announcedRunningSubAgents: [],
-      });
-    });
+  it('reads a legacy state file containing the removed announced-label key and drops the key on the next save', async () => {
+    const at = new Date('2026-06-26T00:00:00Z');
+    fs.writeFileSync(
+      stateFilePath,
+      JSON.stringify({
+        candidates: [
+          {
+            sessionName: sessionAlpha,
+            recordedEpochSeconds: Math.floor(at.getTime() / 1000),
+          },
+        ],
+        announcedRunningSubAgents: [
+          {
+            sessionName: sessionAlpha,
+            labels: ['sub-process-1'],
+            recordedEpochSeconds: Math.floor(at.getTime() / 1000),
+          },
+        ],
+      }),
+    );
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
 
-    it('keeps the announced labels of another session when saving', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-      const at = new Date('2026-06-26T00:00:00Z');
-
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-1'],
-        now: at,
-      });
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionBravo,
-        labels: ['sub-process-2'],
-        now: at,
-      });
-
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
-          sessionName: sessionAlpha,
-        }),
-      ).toEqual(new Set(['sub-process-1']));
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
-          sessionName: sessionBravo,
-        }),
-      ).toEqual(new Set(['sub-process-2']));
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:01:00Z'),
+      recencyWindowSeconds: 15 * 60,
     });
+    expect(loaded).toEqual(new Set([sessionAlpha]));
 
-    it('drops an announced entry that has aged beyond the retention window on the next save', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-      const firstSaveAt = new Date('2026-06-26T00:00:00Z');
-      const secondSaveAt = new Date(
-        firstSaveAt.getTime() +
-          (ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS + 1) * 1000,
-      );
-
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-        labels: ['sub-process-1'],
-        now: firstSaveAt,
-      });
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionBravo,
-        labels: ['sub-process-2'],
-        now: secondSaveAt,
-      });
-
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
-          sessionName: sessionAlpha,
-        }),
-      ).toEqual(new Set<string>());
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
-          sessionName: sessionBravo,
-        }),
-      ).toEqual(new Set(['sub-process-2']));
+    const saveAt = new Date('2026-06-26T00:02:00Z');
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionBravo],
+      now: saveAt,
     });
-
-    it('preserves the candidate set when saving announced labels and preserves announced labels when saving candidates', async () => {
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-      const at = new Date('2026-06-26T00:00:00Z');
-
-      await repository.saveCandidateSessionNames({
-        sessionNames: [sessionAlpha],
-        now: at,
-      });
-      await repository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: sessionBravo,
-        labels: ['sub-process-1'],
-        now: at,
-      });
-      await repository.saveCandidateSessionNames({
-        sessionNames: [sessionAlpha],
-        now: new Date('2026-06-26T00:01:00Z'),
-      });
-
-      const loadedCandidates = await repository.loadRecentCandidateSessionNames(
+    const persisted: unknown = JSON.parse(
+      fs.readFileSync(stateFilePath, 'utf8'),
+    );
+    expect(persisted).toEqual({
+      candidates: [
         {
-          now: new Date('2026-06-26T00:02:00Z'),
-          recencyWindowSeconds: 15 * 60,
+          sessionName: sessionAlpha,
+          recordedEpochSeconds: Math.floor(at.getTime() / 1000),
         },
-      );
-      expect(loadedCandidates).toEqual(new Set([sessionAlpha]));
-      expect(
-        await repository.loadAnnouncedRunningSubAgentLabels({
+        {
           sessionName: sessionBravo,
-        }),
-      ).toEqual(new Set(['sub-process-1']));
-    });
-
-    it('treats a corrupt state file as no recorded announcements', async () => {
-      fs.writeFileSync(stateFilePath, 'not valid json');
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-      });
-
-      expect(loaded).toEqual(new Set<string>());
-    });
-
-    it('ignores a stored announced entry whose labels are malformed', async () => {
-      fs.writeFileSync(
-        stateFilePath,
-        JSON.stringify({
-          candidates: [],
-          announcedRunningSubAgents: [
-            {
-              sessionName: sessionAlpha,
-              labels: ['sub-process-1', 42],
-              recordedEpochSeconds: 1782000000,
-            },
-          ],
-        }),
-      );
-      const repository = new FileSystemSilentSessionCandidateStateRepository(
-        stateFilePath,
-      );
-
-      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: sessionAlpha,
-      });
-
-      expect(loaded).toEqual(new Set<string>());
-    });
-
-    it('exposes the announced-label retention window as a named constant', () => {
-      expect(ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS).toBe(24 * 60 * 60);
+          recordedEpochSeconds: Math.floor(saveAt.getTime() / 1000),
+        },
+      ],
     });
   });
 });

package/src/adapter/repositories/FileSystemSilentSessionCandidateStateRepository.ts

@@ -8,23 +8,24 @@ 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');
   return path.join(base, 'tdpm', 'silent-session-candidates.json');
 };
 
+// Persists only the candidate set used by the two-consecutive-cycle
+// debounce. The formerly persisted announced-running-sub-agent labels
+// (fire-once state for the long-running advisory) were removed: the
+// long-running advisory now re-fires on every qualifying cycle, so no
+// per-label announcement state exists anymore. An old state file that
+// still contains an `announcedRunningSubAgents` key is read without
+// error (unknown keys are ignored) and the key is dropped on the next
+// write.
 export class FileSystemSilentSessionCandidateStateRepository implements SilentSessionCandidateStateRepository {
   constructor(
     private readonly stateFilePath: string = defaultStateFilePath(),
@@ -71,42 +72,7 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
         recordedEpochSeconds,
       });
     }
-    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);
+    this.writeState(Array.from(mergedBySessionName.values()));
   };
 
   private readState = (): Record<string, unknown> => {
@@ -151,49 +117,11 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
     return entries;
   };
 
-  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 => {
+  private writeState = (candidates: StoredCandidateEntry[]): 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, announcedRunningSubAgents }),
-    );
+    fs.writeFileSync(temporaryPath, JSON.stringify({ candidates }));
     fs.renameSync(temporaryPath, this.stateFilePath);
   };
 }

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

@@ -164,7 +164,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     },
   ];
 
-  const toolResultTerminalEntries = (startTimestamp: string): object[] => [
+  const inFlightToolResultTailEntries = (startTimestamp: string): object[] => [
     { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
     {
       type: 'assistant',
@@ -370,13 +370,17 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     expect(result.size).toBe(0);
   });
 
-  it('excludes a dead sub-agent whose transcript ends with an unconsumed tool result and no following assistant turn', async () => {
+  it('keeps an in-flight sub-agent whose transcript tail is an ordinary tool result awaiting the next assistant turn', async () => {
+    // The transcript tail of an actively working agent alternates between a
+    // pending tool_use (assistant) and a tool_result (user). Treating the
+    // tool_result tail as completion made an active agent flap in and out of
+    // the snapshot between samples; it must stay in the snapshot instead.
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     writeAgentTranscript(
       sessionName,
       'toolresultend',
-      toolResultTerminalEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
+      inFlightToolResultTailEntries('2026-06-27T11:50:00.000Z'),
+      nowEpochSeconds - 60,
     );
     const repository = new TranscriptSessionSubAgentActivityRepository(
       createResolver(),
@@ -389,7 +393,14 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
       transcriptMapFor([sessionName]),
     );
 
-    expect(result.size).toBe(0);
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: 'agent-toolresultend',
+        silentSeconds: 60,
+        runningSeconds: 600,
+        waitingOnExternalProcess: false,
+      },
+    ]);
   });
 
   it('excludes a finished sub-agent whose transcript ends with the final StructuredOutput tool result', async () => {
@@ -414,6 +425,58 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     expect(result.size).toBe(0);
   });
 
+  it('keeps an in-flight sub-agent whose tail tool result follows a Bash call even when an earlier turn used StructuredOutput', async () => {
+    // Only the assistant turn immediately preceding the tail tool_result
+    // decides completion: an earlier StructuredOutput call that was already
+    // consumed must not mark a later in-flight tool_result as terminal.
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const startTimestamp = '2026-06-27T11:50:00.000Z';
+    writeAgentTranscript(
+      sessionName,
+      'laterbash',
+      [
+        ...structuredOutputTerminalEntries(startTimestamp),
+        {
+          type: 'assistant',
+          timestamp: startTimestamp,
+          message: {
+            role: 'assistant',
+            stop_reason: 'tool_use',
+            content: [{ type: 'tool_use', name: 'Bash', input: {} }],
+          },
+        },
+        {
+          type: 'user',
+          timestamp: startTimestamp,
+          message: {
+            role: 'user',
+            content: [{ type: 'tool_result', content: 'command output' }],
+          },
+        },
+      ],
+      nowEpochSeconds - 60,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: 'agent-laterbash',
+        silentSeconds: 60,
+        runningSeconds: 600,
+        waitingOnExternalProcess: false,
+      },
+    ]);
+  });
+
   it('excludes a dead sub-agent whose transcript ends with a user entry that has no content blocks', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     writeAgentTranscript(

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -48,7 +48,21 @@ const readContentBlocks = (
   return content.filter(isRecord);
 };
 
-const entryIndicatesCompletion = (entry: Record<string, unknown>): boolean => {
+// Tool whose result marks the sub-agent's final structured answer: once its
+// tool_result is recorded, the sub-agent has delivered its output and is
+// genuinely complete even though the transcript tail is a user entry.
+const COMPLETION_TOOL_NAMES = new Set(['StructuredOutput']);
+
+const entryToolUseNames = (message: Record<string, unknown>): string[] =>
+  readContentBlocks(message)
+    .filter((block) => readString(block, 'type') === 'tool_use')
+    .map((block) => readString(block, 'name'))
+    .filter((name): name is string => name !== null);
+
+const entryIndicatesCompletion = (
+  entry: Record<string, unknown>,
+  precedingAssistantToolUseNames: string[],
+): boolean => {
   const type = readString(entry, 'type');
   const message = entry.message;
   if (!isRecord(message)) {
@@ -70,7 +84,26 @@ const entryIndicatesCompletion = (entry: Record<string, unknown>): boolean => {
     }
     const lastBlock = blocks[blocks.length - 1];
     const lastBlockType = readString(lastBlock, 'type');
-    return lastBlockType === 'text' || lastBlockType === 'tool_result';
+    if (lastBlockType === 'text') {
+      // A trailing user text entry is an interruption (e.g. "[Request
+      // interrupted by user]"): the sub-agent will not produce further
+      // output, so the transcript is terminal.
+      return true;
+    }
+    if (lastBlockType === 'tool_result') {
+      // A trailing tool_result is an IN-FLIGHT state, not completion: the
+      // sub-agent has just received a tool result and the next assistant
+      // turn is being generated. Treating it as completion made an active
+      // agent flap in and out of the activity snapshot between samples
+      // (tail alternates between pending tool_use and tool_result). Only
+      // the result of an explicit completion tool (see
+      // COMPLETION_TOOL_NAMES) is a genuine terminal state, so completed
+      // agents still drop out of the snapshot.
+      return precedingAssistantToolUseNames.some((name) =>
+        COMPLETION_TOOL_NAMES.has(name),
+      );
+    }
+    return false;
   }
   return false;
 };
@@ -102,6 +135,7 @@ const parseTranscript = (content: string): ParsedTranscript => {
   let firstEntryEpochSeconds: number | null = null;
   let lastEntryIndicatesCompletion = false;
   let pendingToolCommands: string[] = [];
+  let precedingAssistantToolUseNames: string[] = [];
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
     if (trimmed.length === 0) {
@@ -121,8 +155,14 @@ const parseTranscript = (content: string): ParsedTranscript => {
       firstEntryEpochSeconds = epochSeconds;
     }
     if (isRecord(parsed.message)) {
-      lastEntryIndicatesCompletion = entryIndicatesCompletion(parsed);
+      lastEntryIndicatesCompletion = entryIndicatesCompletion(
+        parsed,
+        precedingAssistantToolUseNames,
+      );
       pendingToolCommands = entryPendingToolCommands(parsed);
+      if (readString(parsed, 'type') === 'assistant') {
+        precedingAssistantToolUseNames = entryToolUseNames(parsed.message);
+      }
     }
   }
   return {