github-issue-tower-defence-management 2.19.1 → 2.19.3

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

@@ -1,1674 +0,0 @@
-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 { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
-import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
-import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
-
-describe('TranscriptSessionSubAgentActivityRepository', () => {
-  let rootDirectory: string;
-  const now = new Date('2026-06-27T12:00:00.000Z');
-  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-tx-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDirectory, { force: true, recursive: true });
-  });
-
-  const cwdSlugFor = (sessionName: string): string =>
-    `-home-user-worktrees-${sessionName.replace(/[^a-zA-Z0-9]/g, '-')}`;
-
-  const sessionUuidFor = (sessionName: string): string =>
-    `uuid-${sessionName.replace(/[^a-zA-Z0-9]/g, '-')}`;
-
-  const mainTranscriptPathFor = (sessionName: string): string =>
-    path.join(
-      rootDirectory,
-      cwdSlugFor(sessionName),
-      `${sessionUuidFor(sessionName)}.jsonl`,
-    );
-
-  const transcriptMapFor = (sessionNames: string[]): Map<string, string> =>
-    new Map(
-      sessionNames.map((sessionName) => [
-        sessionName,
-        mainTranscriptPathFor(sessionName),
-      ]),
-    );
-
-  const subAgentsDirFor = (sessionName: string): string => {
-    const dir = path.join(
-      rootDirectory,
-      cwdSlugFor(sessionName),
-      sessionUuidFor(sessionName),
-      'subagents',
-    );
-    fs.mkdirSync(dir, { recursive: true });
-    return dir;
-  };
-
-  const writeAgentTranscript = (
-    sessionName: string,
-    agentId: string,
-    entries: object[],
-    mtimeEpochSeconds: number,
-  ): string => {
-    const dir = subAgentsDirFor(sessionName);
-    const filePath = path.join(dir, `agent-${agentId}.jsonl`);
-    fs.writeFileSync(
-      filePath,
-      entries.map((entry) => JSON.stringify(entry)).join('\n'),
-      'utf8',
-    );
-    fs.utimesSync(filePath, mtimeEpochSeconds, mtimeEpochSeconds);
-    return filePath;
-  };
-
-  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' } },
-    {
-      type: 'assistant',
-      timestamp: startTimestamp,
-      message: {
-        role: 'assistant',
-        stop_reason: 'tool_use',
-        content: [{ type: 'tool_use', name: 'Bash', input: {} }],
-      },
-    },
-  ];
-
-  const finishedEntries = (startTimestamp: string): object[] => [
-    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
-    {
-      type: 'assistant',
-      timestamp: startTimestamp,
-      message: { role: 'assistant', stop_reason: 'end_turn' },
-    },
-  ];
-
-  const stopSequenceFinishedEntries = (startTimestamp: string): object[] => [
-    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
-    {
-      type: 'assistant',
-      timestamp: startTimestamp,
-      message: { role: 'assistant', stop_reason: 'stop_sequence' },
-    },
-  ];
-
-  const finalTextAnswerEntries = (startTimestamp: 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: {} }],
-      },
-    },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: {
-        role: 'user',
-        content: [{ type: 'tool_result', content: '' }],
-      },
-    },
-    {
-      type: 'assistant',
-      timestamp: startTimestamp,
-      message: {
-        role: 'assistant',
-        stop_reason: null,
-        content: [{ type: 'text', text: 'All verification complete.' }],
-      },
-    },
-  ];
-
-  const interruptedEntries = (startTimestamp: 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: {} }],
-      },
-    },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: {
-        role: 'user',
-        content: [{ type: 'text', text: '[Request interrupted by user]' }],
-      },
-    },
-  ];
-
-  const inFlightToolResultTailEntries = (startTimestamp: 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: {} }],
-      },
-    },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: {
-        role: 'user',
-        content: [{ type: 'tool_result', content: 'command output' }],
-      },
-    },
-  ];
-
-  const structuredOutputTerminalEntries = (
-    startTimestamp: 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: 'StructuredOutput', input: {} }],
-      },
-    },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: {
-        role: 'user',
-        content: [
-          {
-            type: 'tool_result',
-            content: 'Structured output provided successfully',
-          },
-        ],
-      },
-    },
-  ];
-
-  const emptyUserTerminalEntries = (startTimestamp: 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: {} }],
-      },
-    },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: { role: 'user', content: [] },
-    },
-  ];
-
-  const pendingToolUseEntries = (startTimestamp: string): object[] => [
-    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
-    {
-      type: 'user',
-      timestamp: startTimestamp,
-      message: {
-        role: 'user',
-        content: [{ type: 'tool_result', content: '' }],
-      },
-    },
-    {
-      type: 'assistant',
-      timestamp: startTimestamp,
-      message: {
-        role: 'assistant',
-        stop_reason: 'tool_use',
-        content: [{ type: 'tool_use', name: 'Bash', input: {} }],
-      },
-    },
-  ];
-
-  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';
-    writeAgentTranscript(
-      sessionName,
-      'aaa111',
-      runningEntries(startTimestamp),
-      nowEpochSeconds - 120,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-aaa111',
-        silentSeconds: 120,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('excludes a finished sub-agent whose last entry stop_reason is end_turn', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'done1',
-      finishedEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 30,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    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(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('excludes a finished sub-agent whose last entry is a final assistant text answer with a null stop_reason', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'finaltext',
-      finalTextAnswerEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('excludes a sub-agent whose transcript ends with a user interruption text entry', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'interrupted',
-      interruptedEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  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',
-      inFlightToolResultTailEntries('2026-06-27T11:50:00.000Z'),
-      nowEpochSeconds - 60,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-toolresultend',
-        silentSeconds: 60,
-        runningSeconds: 600,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('excludes a finished sub-agent whose transcript ends with the final StructuredOutput tool result', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'structuredend',
-      structuredOutputTerminalEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    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,
-        finishedResultUnconsumed: 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(
-      sessionName,
-      'emptyuserend',
-      emptyUserTerminalEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('flags a genuinely-active sub-agent whose last entry is a pending tool call', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'pending',
-      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-pending',
-        silentSeconds: 600,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('flags a long-silent genuine stall whose last entry is a pending tool call regardless of how old it is', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const fourDaysSeconds = 4 * 24 * 60 * 60;
-    writeAgentTranscript(
-      sessionName,
-      'longstall',
-      pendingToolUseEntries('2026-06-23T12:00:00.000Z'),
-      nowEpochSeconds - fourDaysSeconds,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-longstall',
-        silentSeconds: fourDaysSeconds,
-        runningSeconds: fourDaysSeconds,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('follows a symlinked transcript when computing silent seconds', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const targetDir = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'subagent-target-'),
-    );
-    const targetPath = path.join(targetDir, 'real-agent.jsonl');
-    fs.writeFileSync(
-      targetPath,
-      runningEntries('2026-06-27T11:50:00.000Z')
-        .map((entry) => JSON.stringify(entry))
-        .join('\n'),
-      'utf8',
-    );
-    fs.utimesSync(targetPath, nowEpochSeconds - 60, nowEpochSeconds - 60);
-    const dir = subAgentsDirFor(sessionName);
-    fs.symlinkSync(targetPath, path.join(dir, 'agent-link1.jsonl'));
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-link1',
-        silentSeconds: 60,
-        runningSeconds: 600,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-    fs.rmSync(targetDir, { force: true, recursive: true });
-  });
-
-  it('returns an empty map when the resolver returns null', async () => {
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      { resolveSubAgentsDirectory: () => null },
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      ['https_//github_com/owner/repo/issues/9'],
-      transcriptMapFor(['https_//github_com/owner/repo/issues/9']),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('ignores a session whose subagents directory does not exist', async () => {
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      ['https_//github_com/owner/repo/issues/404'],
-      transcriptMapFor(['https_//github_com/owner/repo/issues/404']),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('groups multiple running sub-agents under the same session', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'one',
-      runningEntries('2026-06-27T11:55:00.000Z'),
-      nowEpochSeconds - 10,
-    );
-    writeAgentTranscript(
-      sessionName,
-      'two',
-      runningEntries('2026-06-27T11:55:00.000Z'),
-      nowEpochSeconds - 20,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toHaveLength(2);
-  });
-
-  it('clamps negative silent and running seconds to zero', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeAgentTranscript(
-      sessionName,
-      'future',
-      runningEntries('2026-06-27T13:00:00.000Z'),
-      nowEpochSeconds + 100,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-future',
-        silentSeconds: 0,
-        runningSeconds: 0,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('resolves sub-agent transcripts laid out exactly as Claude Code stores them on disk', async () => {
-    const sessionName = 'https_//github_com/HiromiShikata/repo/issues/2355';
-    const projectsRoot = path.join(rootDirectory, 'projects');
-    const cwdSlug =
-      '-home-user-0-workspaces-workspace1-oss-example-repo-worktrees-i2355';
-    const sessionUuid = 'ba0637e1-9ff1-41a8-b13c-f45e6a71efc5';
-    const mainTranscriptPath = path.join(
-      projectsRoot,
-      cwdSlug,
-      `${sessionUuid}.jsonl`,
-    );
-    const subagentsDir = path.join(
-      projectsRoot,
-      cwdSlug,
-      sessionUuid,
-      'subagents',
-    );
-    fs.mkdirSync(subagentsDir, { recursive: true });
-    fs.mkdirSync(path.dirname(mainTranscriptPath), { recursive: true });
-    fs.writeFileSync(mainTranscriptPath, '', 'utf8');
-    const agentFile = path.join(subagentsDir, 'agent-afcbe335fdbec0a28.jsonl');
-    fs.writeFileSync(
-      agentFile,
-      runningEntries('2026-06-27T11:45:00.000Z')
-        .map((entry) => JSON.stringify(entry))
-        .join('\n'),
-      'utf8',
-    );
-    fs.utimesSync(agentFile, nowEpochSeconds - 120, nowEpochSeconds - 120);
-
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      new FileSystemSubAgentTranscriptDirectoryResolver(projectsRoot),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      new Map([[sessionName, mainTranscriptPath]]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-afcbe335fdbec0a28',
-        silentSeconds: 120,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('flags a marker-less stall and excludes a finished transcript in the same session regardless of their age', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const twoDaysSeconds = 2 * 24 * 60 * 60;
-    writeAgentTranscript(
-      sessionName,
-      'finishedold',
-      finishedEntries('2026-06-25T12:00:00.000Z'),
-      nowEpochSeconds - twoDaysSeconds,
-    );
-    writeAgentTranscript(
-      sessionName,
-      'stalledold',
-      pendingToolUseEntries('2026-06-25T12:00:00.000Z'),
-      nowEpochSeconds - twoDaysSeconds,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-stalledold',
-        silentSeconds: twoDaysSeconds,
-        runningSeconds: twoDaysSeconds,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  describe('delegation-wait classification from a pending nested agent tool call', () => {
-    const pendingDelegationEntries = (
-      startTimestamp: string,
-      toolName: 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: toolName,
-              input: { prompt: 'do the sub-task', subagent_type: 'impl' },
-            },
-          ],
-        },
-      },
-    ];
-
-    it.each(['Agent', 'Task'])(
-      'classifies a parent as waiting when its transcript tail is a pending %s tool call spawning a nested child',
-      async (toolName) => {
-        const sessionName = 'https_//github_com/owner/repo/issues/9';
-        writeAgentTranscript(
-          sessionName,
-          'delegating',
-          pendingDelegationEntries('2026-06-27T11:45:00.000Z', toolName),
-          nowEpochSeconds - 600,
-        );
-        const repository = new TranscriptSessionSubAgentActivityRepository(
-          createResolver(),
-          emptyProcessLister(),
-          now,
-        );
-
-        const result = await repository.listSubAgentActivitiesBySessionName(
-          [sessionName],
-          transcriptMapFor([sessionName]),
-        );
-
-        expect(result.get(sessionName)).toEqual([
-          {
-            label: 'agent-delegating',
-            silentSeconds: 600,
-            runningSeconds: 900,
-            waitingOnExternalProcess: true,
-            finishedResultUnconsumed: false,
-          },
-        ]);
-      },
-    );
-
-    it('stops classifying as waiting once the nested agent tool call has returned its tool result', async () => {
-      const sessionName = 'https_//github_com/owner/repo/issues/9';
-      const startTimestamp = '2026-06-27T11:45:00.000Z';
-      writeAgentTranscript(
-        sessionName,
-        'childdone',
-        [
-          ...pendingDelegationEntries(startTimestamp, 'Agent'),
-          {
-            type: 'user',
-            timestamp: startTimestamp,
-            message: {
-              role: 'user',
-              content: [{ type: 'tool_result', content: 'child finished' }],
-            },
-          },
-        ],
-        nowEpochSeconds - 600,
-      );
-      const repository = new TranscriptSessionSubAgentActivityRepository(
-        createResolver(),
-        emptyProcessLister(),
-        now,
-      );
-
-      const result = await repository.listSubAgentActivitiesBySessionName(
-        [sessionName],
-        transcriptMapFor([sessionName]),
-      );
-
-      expect(result.get(sessionName)?.[0]?.waitingOnExternalProcess).toBe(
-        false,
-      );
-    });
-
-    it('does not classify as waiting when a later pending Bash call follows an already-consumed nested agent call', async () => {
-      const sessionName = 'https_//github_com/owner/repo/issues/9';
-      const startTimestamp = '2026-06-27T11:45:00.000Z';
-      writeAgentTranscript(
-        sessionName,
-        'laterpending',
-        [
-          ...pendingDelegationEntries(startTimestamp, 'Agent'),
-          {
-            type: 'user',
-            timestamp: startTimestamp,
-            message: {
-              role: 'user',
-              content: [{ type: 'tool_result', content: 'child finished' }],
-            },
-          },
-          {
-            type: 'assistant',
-            timestamp: startTimestamp,
-            message: {
-              role: 'assistant',
-              stop_reason: 'tool_use',
-              content: [{ type: 'tool_use', name: 'Bash', input: {} }],
-            },
-          },
-        ],
-        nowEpochSeconds - 600,
-      );
-      const repository = new TranscriptSessionSubAgentActivityRepository(
-        createResolver(),
-        emptyProcessLister(),
-        now,
-      );
-
-      const result = await repository.listSubAgentActivitiesBySessionName(
-        [sessionName],
-        transcriptMapFor([sessionName]),
-      );
-
-      expect(result.get(sessionName)?.[0]?.waitingOnExternalProcess).toBe(
-        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,
-          finishedResultUnconsumed: false,
-        },
-      ]);
-    });
-
-    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,
-          finishedResultUnconsumed: 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);
-    });
-  });
-
-  const writeMainTranscript = (sessionName: string, lines: object[]): void => {
-    const filePath = mainTranscriptPathFor(sessionName);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(
-      filePath,
-      lines.map((line) => JSON.stringify(line)).join('\n'),
-      'utf8',
-    );
-  };
-
-  const killedNotificationEntry = (
-    agentId: string,
-    timestamp: string,
-  ): object => ({
-    type: 'queue-operation',
-    operation: 'enqueue',
-    timestamp,
-    content: `<task-notification>\n<task-id>${agentId}</task-id>\n<status>killed</status>\n</task-notification>`,
-  });
-
-  const failedNotificationEntry = (
-    agentId: string,
-    timestamp: string,
-  ): object => ({
-    type: 'queue-operation',
-    operation: 'enqueue',
-    timestamp,
-    content: `<task-notification>\n<task-id>${agentId}</task-id>\n<status>failed</status>\n</task-notification>`,
-  });
-
-  const completedNotificationEntry = (
-    agentId: string,
-    timestamp: string,
-  ): object => ({
-    type: 'queue-operation',
-    operation: 'enqueue',
-    timestamp,
-    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';
-    writeAgentTranscript(
-      sessionName,
-      killedAgentId,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 300,
-    );
-    writeMainTranscript(sessionName, [
-      killedNotificationEntry(killedAgentId, '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 a sub-agent whose process crashed when the parent transcript records a failed notification for its id', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const failedAgentId = 'aaabbbbcccc00002';
-    writeAgentTranscript(
-      sessionName,
-      failedAgentId,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 300,
-    );
-    writeMainTranscript(sessionName, [
-      failedNotificationEntry(failedAgentId, '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 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';
-    writeAgentTranscript(
-      sessionName,
-      completedAgentId,
-      pendingToolUseEntries(startTimestamp),
-      nowEpochSeconds - 120,
-    );
-    writeMainTranscript(sessionName, [
-      completedNotificationEntry(completedAgentId, '2026-06-27T11:58:00.000Z'),
-    ]);
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    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, [
-      {
-        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 () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const killedAgentId = 'aaabbbbcccc00004';
-    const aliveAgentId = 'aaabbbbcccc00005';
-    writeAgentTranscript(
-      sessionName,
-      killedAgentId,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    writeAgentTranscript(
-      sessionName,
-      aliveAgentId,
-      runningEntries('2026-06-27T11:45:00.000Z'),
-      nowEpochSeconds - 120,
-    );
-    writeMainTranscript(sessionName, [
-      killedNotificationEntry(killedAgentId, '2026-06-27T11:55:00.000Z'),
-    ]);
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${aliveAgentId}`,
-        silentSeconds: 120,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  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,
-        finishedResultUnconsumed: 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';
-    writeAgentTranscript(
-      sessionName,
-      'aabb1122cc3344ee',
-      runningEntries(startTimestamp),
-      nowEpochSeconds - 120,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: 'agent-aabb1122cc3344ee',
-        silentSeconds: 120,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('reports a finished sub-agent still listed in the running-subagents record as an unconsumed result carrying its silence age', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const unconsumedAgentId = 'aaabbbbcccc30001';
-    writeAgentTranscript(
-      sessionName,
-      unconsumedAgentId,
-      finishedEntries('2026-06-27T10:30:00.000Z'),
-      nowEpochSeconds - 5220,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith([unconsumedAgentId]),
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${unconsumedAgentId}`,
-        silentSeconds: 5220,
-        runningSeconds: 5400,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: true,
-      },
-    ]);
-  });
-
-  it('reports a finished sub-agent whose tail is a final text answer as an unconsumed result while it stays in the running-subagents record', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const unconsumedAgentId = 'aaabbbbcccc30002';
-    writeAgentTranscript(
-      sessionName,
-      unconsumedAgentId,
-      finalTextAnswerEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 360,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith([unconsumedAgentId]),
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${unconsumedAgentId}`,
-        silentSeconds: 360,
-        runningSeconds: 3600,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: true,
-      },
-    ]);
-  });
-
-  it('discards a finished sub-agent when the running-subagents record cannot be resolved', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const finishedAgentId = 'aaabbbbcccc30003';
-    writeAgentTranscript(
-      sessionName,
-      finishedAgentId,
-      finishedEntries('2026-06-27T10:30:00.000Z'),
-      nowEpochSeconds - 5220,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith(null),
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('discards a finished sub-agent whose id has already been removed from the running-subagents record', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const finishedAgentId = 'aaabbbbcccc30004';
-    writeAgentTranscript(
-      sessionName,
-      finishedAgentId,
-      finishedEntries('2026-06-27T10:30:00.000Z'),
-      nowEpochSeconds - 5220,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith(['aaabbbbcccc30005']),
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('reports a still-working sub-agent listed in the running-subagents record as having no unconsumed result', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const workingAgentId = 'aaabbbbcccc30006';
-    writeAgentTranscript(
-      sessionName,
-      workingAgentId,
-      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith([workingAgentId]),
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${workingAgentId}`,
-        silentSeconds: 600,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  const outputFilePathFor = (sessionName: string, agentId: string): string => {
-    const mainTranscriptPath = mainTranscriptPathFor(sessionName);
-    const slug = path.basename(path.dirname(mainTranscriptPath));
-    const sid = path.basename(mainTranscriptPath, '.jsonl');
-    return path.join(rootDirectory, slug, sid, 'tasks', `${agentId}.output`);
-  };
-
-  const createOutputFile = (sessionName: string, agentId: string): void => {
-    const filePath = outputFilePathFor(sessionName, agentId);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, '', 'utf8');
-  };
-
-  it('excludes a sub-agent whose output file is absent and whose id matches no running process when the liveness file is absent', async () => {
-    const sessionName = 'session-4161-ghost-agent';
-    const agentId = 'a4161dead00000001';
-    writeAgentTranscript(
-      sessionName,
-      agentId,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith(null),
-      rootDirectory,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-
-  it('includes a sub-agent whose output file exists even when the liveness file is absent', async () => {
-    const sessionName = 'session-4161-live-output';
-    const agentId = 'a4161live00000002';
-    writeAgentTranscript(
-      sessionName,
-      agentId,
-      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    createOutputFile(sessionName, agentId);
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith(null),
-      rootDirectory,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${agentId}`,
-        silentSeconds: 600,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('includes a sub-agent whose output file is absent but whose id appears in a running process command line when the liveness file is absent', async () => {
-    const sessionName = 'session-4161-live-process';
-    const agentId = 'a4161proc00000003';
-    writeAgentTranscript(
-      sessionName,
-      agentId,
-      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
-      nowEpochSeconds - 600,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      processListerWith([
-        {
-          commandLine: `/path/to/claude --session ${agentId} --task task.txt`,
-          elapsedSeconds: 600,
-        },
-      ]),
-      now,
-      livenessResolverWith(null),
-      rootDirectory,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.get(sessionName)).toEqual([
-      {
-        label: `agent-${agentId}`,
-        silentSeconds: 600,
-        runningSeconds: 900,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-
-  it('emits no sub-agent entries when every transcript has no output file and no matching process and the liveness file is absent', async () => {
-    const sessionName = 'session-4161-all-absent';
-    const agentId1 = 'a4161none00000004';
-    const agentId2 = 'a4161none00000005';
-    writeAgentTranscript(
-      sessionName,
-      agentId1,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 900,
-    );
-    writeAgentTranscript(
-      sessionName,
-      agentId2,
-      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
-      nowEpochSeconds - 900,
-    );
-    const repository = new TranscriptSessionSubAgentActivityRepository(
-      createResolver(),
-      emptyProcessLister(),
-      now,
-      livenessResolverWith(null),
-      rootDirectory,
-    );
-
-    const result = await repository.listSubAgentActivitiesBySessionName(
-      [sessionName],
-      transcriptMapFor([sessionName]),
-    );
-
-    expect(result.size).toBe(0);
-  });
-});