github-issue-tower-defence-management 1.138.0 → 1.139.1

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

@@ -0,0 +1,127 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSilentSessionNotifiedStateRepository } from './FileSystemSilentSessionNotifiedStateRepository';
+
+describe('FileSystemSilentSessionNotifiedStateRepository', () => {
+  let rootDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'silent-session-notified-state-'),
+    );
+    stateFilePath = path.join(rootDirectory, 'silent-session-notified.json');
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const sessionAlpha = 'https://github.com/HiromiShikata/repo/issues/100';
+  const sessionBravo = 'https://github.com/HiromiShikata/repo/issues/200';
+
+  it('round-trips a saved notified set so the next cycle reads it back', async () => {
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha, sessionBravo],
+      now,
+    });
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:01:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha, sessionBravo]));
+  });
+
+  it('returns an empty set when no state file exists yet', async () => {
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:00:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+
+  it('excludes an entry older than the recency window when loading', async () => {
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha],
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:20:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+
+  it('overwrites the latch on save so a pruned session no longer lingers', async () => {
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha, sessionBravo],
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha],
+      now: new Date('2026-06-26T00:01:30Z'),
+    });
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:02:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha]));
+  });
+
+  it('refreshes the recorded timestamp on each save so a continuously latched session stays within the window', async () => {
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha],
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveNotifiedSessionNames({
+      sessionNames: [sessionAlpha],
+      now: new Date('2026-06-26T00:14:00Z'),
+    });
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:20:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha]));
+  });
+
+  it('returns an empty set when the state file is not valid JSON', async () => {
+    fs.writeFileSync(stateFilePath, 'not json');
+    const repository = new FileSystemSilentSessionNotifiedStateRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadRecentNotifiedSessionNames({
+      now: new Date('2026-06-26T00:00:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+});

package/src/adapter/repositories/FileSystemSilentSessionNotifiedStateRepository.ts

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SilentSessionNotifiedStateRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotifiedStateRepository';
+
+type StoredNotifiedEntry = {
+  sessionName: string;
+  recordedEpochSeconds: number;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'silent-session-notified.json');
+};
+
+// Persists the fire-once latch: the set of session names that have already
+// received the current silent-episode reminder. The use case re-writes the
+// full latch each cycle with the current timestamp, keeping a session latched
+// for as long as it stays a reminder candidate (a continuous silent episode
+// produces exactly one reminder), and prunes a session the moment it stops
+// being a candidate so a later re-qualification fires again. The save
+// intentionally OVERWRITES rather than merges: the use case supplies the
+// complete latch to persist, so a pruned session must not linger.
+export class FileSystemSilentSessionNotifiedStateRepository implements SilentSessionNotifiedStateRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+  ) {}
+
+  loadRecentNotifiedSessionNames = async (params: {
+    now: Date;
+    recencyWindowSeconds: number;
+  }): Promise<Set<string>> => {
+    const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestAllowedEpochSeconds =
+      nowEpochSeconds - params.recencyWindowSeconds;
+    const recentSessionNames = new Set<string>();
+    for (const entry of this.readNotifiedEntries()) {
+      if (entry.recordedEpochSeconds >= oldestAllowedEpochSeconds) {
+        recentSessionNames.add(entry.sessionName);
+      }
+    }
+    return recentSessionNames;
+  };
+
+  saveNotifiedSessionNames = async (params: {
+    sessionNames: string[];
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const notifiedBySessionName = new Map<string, StoredNotifiedEntry>();
+    for (const sessionName of params.sessionNames) {
+      notifiedBySessionName.set(sessionName, {
+        sessionName,
+        recordedEpochSeconds,
+      });
+    }
+    this.writeState(Array.from(notifiedBySessionName.values()));
+  };
+
+  private readNotifiedEntries = (): StoredNotifiedEntry[] => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch {
+      return [];
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!isRecord(parsed)) {
+      return [];
+    }
+    const storedEntries = parsed.notified;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredNotifiedEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      if (
+        typeof sessionName === 'string' &&
+        typeof recordedEpochSeconds === 'number' &&
+        Number.isFinite(recordedEpochSeconds)
+      ) {
+        entries.push({ sessionName, recordedEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeState = (notified: StoredNotifiedEntry[]): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporaryPath, JSON.stringify({ notified }));
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}

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

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSubAgentLivenessResolver } from './FileSystemSubAgentLivenessResolver';
+
+describe('FileSystemSubAgentLivenessResolver', () => {
+  let runtimeRoot: string;
+  const cwdSlug = '-home-user-worktrees-issue-9';
+  const sessionUuid = 'ba0637e1-9ff1-41a8-b13c-f45e6a71efc5';
+  const sessionName = 'https_//github_com/owner/repo/issues/9';
+  const mainTranscriptPath = path.join(
+    '/home/user/.config/projects',
+    cwdSlug,
+    `${sessionUuid}.jsonl`,
+  );
+
+  beforeEach(() => {
+    runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-live-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(runtimeRoot, { force: true, recursive: true });
+  });
+
+  const writeRunningFile = (contents: string): void => {
+    const dir = path.join(runtimeRoot, cwdSlug, sessionUuid);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'running-subagents.txt'), contents, 'utf8');
+  };
+
+  it('returns the trimmed non-empty ids listed in running-subagents.txt', async () => {
+    writeRunningFile('a70a08e0587d6f484\n\n  ad5d15d239d7e72e8  \n');
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toEqual(new Set(['a70a08e0587d6f484', 'ad5d15d239d7e72e8']));
+  });
+
+  it('returns an empty set when the running file exists but lists no ids', async () => {
+    writeRunningFile('\n   \n');
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toEqual(new Set());
+  });
+
+  it('returns null when the running file does not exist', async () => {
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it('returns null when the runtime root directory is null', async () => {
+    const resolver = new FileSystemSubAgentLivenessResolver(null);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it('returns null when the main transcript path is null', async () => {
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath: null,
+    });
+
+    expect(result).toBeNull();
+  });
+});

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts

@@ -0,0 +1,57 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
+
+const RUNNING_SUBAGENTS_FILE_NAME = 'running-subagents.txt';
+
+export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResolver {
+  constructor(private readonly runtimeRootDirectory: string | null) {}
+
+  resolveLiveSubAgentIds = async (params: {
+    sessionName: string;
+    mainTranscriptPath: string | null;
+  }): Promise<Set<string> | null> => {
+    const runningFilePath = this.resolveRunningSubAgentsFilePath(
+      params.mainTranscriptPath,
+    );
+    if (runningFilePath === null) {
+      return null;
+    }
+    let content: string;
+    try {
+      content = fs.readFileSync(runningFilePath, 'utf8');
+    } catch {
+      return null;
+    }
+    const liveIds = new Set<string>();
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) {
+        liveIds.add(trimmed);
+      }
+    }
+    return liveIds;
+  };
+
+  private resolveRunningSubAgentsFilePath = (
+    mainTranscriptPath: string | null,
+  ): string | null => {
+    if (this.runtimeRootDirectory === null || mainTranscriptPath === null) {
+      return null;
+    }
+    const sessionUuid = path.basename(mainTranscriptPath, '.jsonl');
+    if (sessionUuid.length === 0 || sessionUuid.endsWith('.jsonl')) {
+      return null;
+    }
+    const cwdSlug = path.basename(path.dirname(mainTranscriptPath));
+    if (cwdSlug.length === 0 || cwdSlug === '.') {
+      return null;
+    }
+    return path.join(
+      this.runtimeRootDirectory,
+      cwdSlug,
+      sessionUuid,
+      RUNNING_SUBAGENTS_FILE_NAME,
+    );
+  };
+}

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

@@ -13,7 +13,7 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
 
 describe('TmuxSilentSessionNotificationRepository', () => {
   describe('sendSelfCheckNotification', () => {
-    it('sends the message literally then submits it with Enter', async () => {
+    it('wraps the message in bracketed-paste framing, sends it literally, then submits it with Enter', async () => {
       const runner = createMockRunner();
       const repository = new TmuxSilentSessionNotificationRepository(runner);
 
@@ -29,7 +29,7 @@ describe('TmuxSilentSessionNotificationRepository', () => {
           '-t',
           'https_//github_com/owner/repo/issues/9',
           '-l',
-          'self check message',
+          '\x1b[200~self check message\x1b[201~',
         ],
       ]);
       expect(runner.runCommand.mock.calls[1]).toEqual([
@@ -38,6 +38,27 @@ describe('TmuxSilentSessionNotificationRepository', () => {
       ]);
     });
 
+    it('preserves an unchanged multi-line message body inside the bracketed-paste frame', async () => {
+      const runner = createMockRunner();
+      const repository = new TmuxSilentSessionNotificationRepository(runner);
+      const multiLineMessage = 'first line\nsecond line\n\nthird line';
+
+      await repository.sendSelfCheckNotification(
+        'https_//github_com/owner/repo/issues/9',
+        multiLineMessage,
+      );
+
+      const literalArgument = runner.runCommand.mock.calls[0][1][4];
+      expect(literalArgument.startsWith('\x1b[200~')).toBe(true);
+      expect(literalArgument.endsWith('\x1b[201~')).toBe(true);
+      expect(
+        literalArgument.slice('\x1b[200~'.length, -'\x1b[201~'.length),
+      ).toBe(multiLineMessage);
+      const literalBytes = Buffer.from(literalArgument, 'utf8').toString('hex');
+      expect(literalBytes.startsWith('1b5b3230307e')).toBe(true);
+      expect(literalBytes.endsWith('1b5b3230317e')).toBe(true);
+    });
+
     it('throws when sending the message literally fails', async () => {
       const runner = createMockRunner();
       runner.runCommand.mockResolvedValueOnce({

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts

@@ -1,6 +1,9 @@
 import { SilentSessionNotificationRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotificationRepository';
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 
+const BRACKETED_PASTE_START = '\x1b[200~';
+const BRACKETED_PASTE_END = '\x1b[201~';
+
 export class TmuxSilentSessionNotificationRepository implements SilentSessionNotificationRepository {
   constructor(private readonly localCommandRunner: LocalCommandRunner) {}
 
@@ -8,12 +11,13 @@ export class TmuxSilentSessionNotificationRepository implements SilentSessionNot
     sessionName: string,
     message: string,
   ): Promise<void> => {
+    const framedMessage = `${BRACKETED_PASTE_START}${message}${BRACKETED_PASTE_END}`;
     const literalResult = await this.localCommandRunner.runCommand('tmux', [
       'send-keys',
       '-t',
       sessionName,
       '-l',
-      message,
+      framedMessage,
     ]);
     if (literalResult.exitCode !== 0) {
       throw new Error(

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

@@ -6,6 +6,7 @@ import {
   SubAgentProcess,
   SubAgentProcessLister,
 } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
+import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
 import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
 import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
 
@@ -1085,6 +1086,23 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     content: `<task-notification>\n<task-id>${agentId}</task-id>\n<status>completed</status>\n</task-notification>`,
   });
 
+  const stoppedNotificationEntry = (
+    agentId: string,
+    timestamp: string,
+  ): object => ({
+    type: 'queue-operation',
+    operation: 'enqueue',
+    timestamp,
+    content: `<task-notification>\n<task-id>${agentId}</task-id>\n<status>stopped</status>\n</task-notification>`,
+  });
+
+  const livenessResolverWith = (
+    liveIds: string[] | null,
+  ): SubAgentLivenessResolver => ({
+    resolveLiveSubAgentIds: async () =>
+      liveIds === null ? null : new Set(liveIds),
+  });
+
   it('excludes a sub-agent killed via TaskStop when the parent transcript records a killed notification for its id', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     const killedAgentId = 'aaabbbbcccc00001';
@@ -1137,7 +1155,7 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     expect(result.size).toBe(0);
   });
 
-  it('does not exclude a sub-agent whose parent transcript records only a completed notification for its id', async () => {
+  it('excludes a sub-agent whose parent transcript records a completed notification for its id', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     const startTimestamp = '2026-06-27T11:45:00.000Z';
     const completedAgentId = 'aaabbbbcccc00003';
@@ -1161,14 +1179,71 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
       transcriptMapFor([sessionName]),
     );
 
-    expect(result.get(sessionName)).toEqual([
+    expect(result.size).toBe(0);
+  });
+
+  it('excludes a sub-agent whose parent transcript records a stopped notification for its id', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const stoppedAgentId = 'aaabbbbcccc00006';
+    writeAgentTranscript(
+      sessionName,
+      stoppedAgentId,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 300,
+    );
+    writeMainTranscript(sessionName, [
+      stoppedNotificationEntry(stoppedAgentId, '2026-06-27T11:55:00.000Z'),
+    ]);
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.size).toBe(0);
+  });
+
+  it('excludes every task id listed in a single multi-id terminal notification', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const firstAgentId = 'aaabbbbcccc10001';
+    const secondAgentId = 'aaabbbbcccc10002';
+    writeAgentTranscript(
+      sessionName,
+      firstAgentId,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 300,
+    );
+    writeAgentTranscript(
+      sessionName,
+      secondAgentId,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 300,
+    );
+    writeMainTranscript(sessionName, [
       {
-        label: `agent-${completedAgentId}`,
-        silentSeconds: 120,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
+        type: 'queue-operation',
+        operation: 'enqueue',
+        timestamp: '2026-06-27T11:55:00.000Z',
+        content: `<task-notification>\n<task-id>${firstAgentId}</task-id>\n<task-id>${secondAgentId}</task-id>\n<status>completed</status>\n</task-notification>`,
       },
     ]);
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.size).toBe(0);
   });
 
   it('excludes a killed sub-agent but reports a still-active sibling in the same session', async () => {
@@ -1211,6 +1286,61 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
     ]);
   });
 
+  it('excludes a stale sub-agent whose tail is a plain tool result when no live process exists for its id', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const deadAgentId = 'aaabbbbcccc20001';
+    writeAgentTranscript(
+      sessionName,
+      deadAgentId,
+      inFlightToolResultTailEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 3600,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+      livenessResolverWith(['aaabbbbcccc20002']),
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.size).toBe(0);
+  });
+
+  it('flags a genuinely-running silent sub-agent whose id is present in the live process set', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const liveAgentId = 'aaabbbbcccc20003';
+    writeAgentTranscript(
+      sessionName,
+      liveAgentId,
+      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
+      nowEpochSeconds - 600,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+      livenessResolverWith([liveAgentId]),
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: `agent-${liveAgentId}`,
+        silentSeconds: 600,
+        runningSeconds: 900,
+        waitingOnExternalProcess: false,
+      },
+    ]);
+  });
+
   it('reports a sub-agent even when the parent transcript path does not exist', async () => {
     const sessionName = 'https_//github_com/owner/repo/issues/9';
     const startTimestamp = '2026-06-27T11:45:00.000Z';