github-issue-tower-defence-management 1.140.2 → 1.142.0

package/src/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.ts

@@ -0,0 +1,71 @@
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import {
+  SessionOutputDegenerationRecoveryUseCase,
+  DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS,
+  DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS,
+  DEFAULT_OUTPUT_DEGENERATION_WARNING_MESSAGE,
+} from '../../../domain/usecases/SessionOutputDegenerationRecoveryUseCase';
+import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
+import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
+import { FileSystemSessionAssistantTurnsRepository } from '../../repositories/FileSystemSessionAssistantTurnsRepository';
+import { FileSystemSessionDegenerationCooldownStateRepository } from '../../repositories/FileSystemSessionDegenerationCooldownStateRepository';
+import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+import { RealSleeper } from '../../repositories/RealSleeper';
+
+export type ResetDegeneratedTmuxSessionsParams = {
+  enabled: boolean;
+  localCommandRunner: LocalCommandRunner;
+  processEnvironReader?: ProcessEnvironReader;
+  warningMessage: string;
+  graceSeconds: number;
+  cooldownSeconds: number;
+  cooldownStateFilePath: string | null;
+  now: Date;
+};
+
+export const resetDegeneratedTmuxSessions = async (
+  params: ResetDegeneratedTmuxSessionsParams,
+): Promise<void> => {
+  const {
+    enabled,
+    localCommandRunner,
+    processEnvironReader,
+    warningMessage,
+    graceSeconds,
+    cooldownSeconds,
+    cooldownStateFilePath,
+    now,
+  } = params;
+  const useCase = new SessionOutputDegenerationRecoveryUseCase(
+    new LocalProcessLiveSessionProcessSnapshotProvider(
+      localCommandRunner,
+      processEnvironReader ?? new ProcFsProcessEnvironReader(),
+    ),
+    new FileSystemInteractiveLiveSessionTranscriptResolver(),
+    new FileSystemSessionAssistantTurnsRepository(),
+    new TmuxSilentSessionNotificationRepository(localCommandRunner),
+    new NodeTmuxSessionRepository(localCommandRunner),
+    cooldownStateFilePath !== null
+      ? new FileSystemSessionDegenerationCooldownStateRepository(
+          cooldownStateFilePath,
+        )
+      : new FileSystemSessionDegenerationCooldownStateRepository(),
+    new RealSleeper(),
+  );
+  await useCase.run({
+    enabled,
+    warningMessage,
+    graceSeconds,
+    cooldownSeconds,
+    now,
+  });
+};
+
+export const DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS = {
+  warningMessage: DEFAULT_OUTPUT_DEGENERATION_WARNING_MESSAGE,
+  graceSeconds: DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS,
+  cooldownSeconds: DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS,
+} as const;

package/src/adapter/entry-points/handlers/tokenStatusWriter.test.ts

@@ -128,6 +128,11 @@ describe('writeTokenStatus', () => {
     const written = readJson(path.join(dir, 'token-status.json'));
     const expected: TokenStatusFile = {
       capturedAt: '2026-06-26T12:00:00.000Z',
+      sevenDayWindowAggregate: {
+        usedPercent: 50,
+        includedTokenCount: 1,
+        totalTokenCount: 2,
+      },
       tokens: [
         {
           name: 'alice',
@@ -216,6 +221,7 @@ describe('writeTokenStatus', () => {
     };
     expect(written).toEqual({
       capturedAt: '2026-06-26T12:00:00.000Z',
+      sevenDayWindowAggregate: null,
       tokens: [
         expectedAlice,
         {

package/src/adapter/entry-points/handlers/tokenStatusWriter.ts

@@ -4,9 +4,11 @@ import type { Issue } from '../../../domain/entities/Issue';
 import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
 import {
   GenerateTokenStatusUseCase,
+  SevenDayWindowAggregate,
   TokenRateLimitSnapshot,
   TokenStatus,
   TokenStatusInput,
+  computeSevenDayWindowAggregate,
 } from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
 import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
 import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
@@ -35,6 +37,7 @@ export type TokenStatusWriterParams = {
 
 export type TokenStatusFile = {
   tokens: TokenStatus[];
+  sevenDayWindowAggregate: SevenDayWindowAggregate | null;
   capturedAt: string;
 };
 
@@ -247,6 +250,7 @@ export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
 
   const file: TokenStatusFile = {
     tokens,
+    sevenDayWindowAggregate: computeSevenDayWindowAggregate(tokens),
     capturedAt: now.toISOString(),
   };
 

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

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionAssistantTurnsRepository } from './FileSystemSessionAssistantTurnsRepository';
+
+describe('FileSystemSessionAssistantTurnsRepository', () => {
+  let temporaryDirectory: string;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'assistant-turns-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  const writeTranscript = (fileName: string, lines: string[]): string => {
+    const filePath = path.join(temporaryDirectory, fileName);
+    fs.writeFileSync(filePath, `${lines.join('\n')}\n`);
+    return filePath;
+  };
+
+  it('returns recent assistant turn texts newest first, ignoring non-assistant lines', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'first turn' }] },
+      }),
+      JSON.stringify({
+        type: 'user',
+        message: { content: [{ type: 'text', text: 'a user turn' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'text', text: 'second turn' },
+            { type: 'tool_use', id: 'tool-1', name: 'Bash' },
+          ],
+        },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'third turn' }] },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual([
+      'third turn',
+      'second turn',
+      'first turn',
+    ]);
+  });
+
+  it('limits the number of turns returned to maxTurnsPerSession', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'oldest' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'middle' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'newest' }] },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      2,
+    );
+
+    expect(result.get('session')).toEqual(['newest', 'middle']);
+  });
+
+  it('reads a string content assistant message', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: 'plain string turn' },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual(['plain string turn']);
+  });
+
+  it('omits a session whose transcript is missing', async () => {
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', path.join(temporaryDirectory, 'absent.jsonl')]]),
+      10,
+    );
+
+    expect(result.has('session')).toBe(false);
+  });
+
+  it('drops the first partial line when reading only the transcript tail', async () => {
+    const firstLine = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'partial old turn' }] },
+    });
+    const secondLine = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'complete new turn' }] },
+    });
+    const filePath = writeTranscript('transcript.jsonl', [
+      firstLine,
+      secondLine,
+    ]);
+
+    const tailBytes = Buffer.byteLength(`${secondLine}\n`) + 5;
+    const repository = new FileSystemSessionAssistantTurnsRepository(tailBytes);
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual(['complete new turn']);
+  });
+});

package/src/adapter/repositories/FileSystemSessionAssistantTurnsRepository.ts

@@ -0,0 +1,113 @@
+import * as fs from 'fs';
+import { SessionAssistantTurnsRepository } from '../../domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository';
+
+export const DEFAULT_TRANSCRIPT_TAIL_BYTES = 3_000_000;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const assistantText = (message: Record<string, unknown>): string => {
+  const content = message.content;
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const block of content) {
+      if (
+        isRecord(block) &&
+        block.type === 'text' &&
+        typeof block.text === 'string'
+      ) {
+        parts.push(block.text);
+      }
+    }
+    return parts.join(' ');
+  }
+  return '';
+};
+
+export class FileSystemSessionAssistantTurnsRepository implements SessionAssistantTurnsRepository {
+  constructor(
+    private readonly tailBytes: number = DEFAULT_TRANSCRIPT_TAIL_BYTES,
+  ) {}
+
+  listRecentAssistantTurnsBySessionName = async (
+    transcriptPathBySessionName: Map<string, string>,
+    maxTurnsPerSession: number,
+  ): Promise<Map<string, string[]>> => {
+    const turnsBySessionName = new Map<string, string[]>();
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      const turns = this.readRecentAssistantTurns(
+        transcriptPath,
+        maxTurnsPerSession,
+      );
+      if (turns.length > 0) {
+        turnsBySessionName.set(sessionName, turns);
+      }
+    }
+    return turnsBySessionName;
+  };
+
+  private readRecentAssistantTurns = (
+    transcriptPath: string,
+    maxTurns: number,
+  ): string[] => {
+    const lines = this.readTailLines(transcriptPath);
+    const turns: string[] = [];
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const trimmed = lines[index].trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed) || parsed.type !== 'assistant') {
+        continue;
+      }
+      const message = parsed.message;
+      if (!isRecord(message)) {
+        continue;
+      }
+      const text = assistantText(message);
+      if (text.trim().length === 0) {
+        continue;
+      }
+      turns.push(text);
+      if (turns.length >= maxTurns) {
+        break;
+      }
+    }
+    return turns;
+  };
+
+  private readTailLines = (transcriptPath: string): string[] => {
+    let handle: number;
+    try {
+      handle = fs.openSync(transcriptPath, 'r');
+    } catch {
+      return [];
+    }
+    try {
+      const size = fs.fstatSync(handle).size;
+      const start = size > this.tailBytes ? size - this.tailBytes : 0;
+      const length = size - start;
+      const buffer = new Uint8Array(length);
+      fs.readSync(handle, buffer, 0, length, start);
+      let text = Buffer.from(buffer).toString('utf8');
+      if (start > 0) {
+        const newlineIndex = text.indexOf('\n');
+        text = newlineIndex === -1 ? '' : text.slice(newlineIndex + 1);
+      }
+      return text.split('\n');
+    } catch {
+      return [];
+    } finally {
+      fs.closeSync(handle);
+    }
+  };
+}

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

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionDegenerationCooldownStateRepository } from './FileSystemSessionDegenerationCooldownStateRepository';
+
+describe('FileSystemSessionDegenerationCooldownStateRepository', () => {
+  let temporaryDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'degeneration-cooldown-'),
+    );
+    stateFilePath = path.join(temporaryDirectory, 'cooldown.json');
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  it('returns an empty map when no state file exists', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    expect(await repository.loadLastResetEpochSecondsBySessionName()).toEqual(
+      new Map(),
+    );
+  });
+
+  it('persists and reloads a per-session reset time', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-07-26T00:00:00Z');
+    await repository.recordReset({ sessionName: 'session-a', now });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(Math.floor(now.getTime() / 1000));
+  });
+
+  it('keeps distinct sessions separate and overwrites the same session', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-b',
+      now: new Date('2026-07-26T00:01:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:02:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(
+      Math.floor(new Date('2026-07-26T00:02:00Z').getTime() / 1000),
+    );
+    expect(reloaded.get('session-b')).toBe(
+      Math.floor(new Date('2026-07-26T00:01:00Z').getTime() / 1000),
+    );
+  });
+
+  it('drops entries older than the retention window on the next write', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+      60,
+    );
+    await repository.recordReset({
+      sessionName: 'stale-session',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'fresh-session',
+      now: new Date('2026-07-26T00:05:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.has('stale-session')).toBe(false);
+    expect(reloaded.has('fresh-session')).toBe(true);
+  });
+});

package/src/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.ts

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SessionDegenerationCooldownStateRepository } from '../../domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository';
+
+type StoredResetEntry = {
+  sessionName: string;
+  resetEpochSeconds: number;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const DEFAULT_RESET_RETENTION_WINDOW_SECONDS = 60 * 60;
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'output-degeneration-cooldown.json');
+};
+
+export class FileSystemSessionDegenerationCooldownStateRepository implements SessionDegenerationCooldownStateRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_RESET_RETENTION_WINDOW_SECONDS,
+  ) {}
+
+  loadLastResetEpochSecondsBySessionName = async (): Promise<
+    Map<string, number>
+  > => {
+    const lastResetBySessionName = new Map<string, number>();
+    for (const entry of this.readResetEntries()) {
+      lastResetBySessionName.set(entry.sessionName, entry.resetEpochSeconds);
+    }
+    return lastResetBySessionName;
+  };
+
+  recordReset = async (params: {
+    sessionName: string;
+    now: Date;
+  }): Promise<void> => {
+    const resetEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      resetEpochSeconds - this.retentionWindowSeconds;
+    const mergedBySessionName = new Map<string, StoredResetEntry>();
+    for (const entry of this.readResetEntries()) {
+      if (
+        entry.resetEpochSeconds >= oldestRetainedEpochSeconds &&
+        entry.sessionName !== params.sessionName
+      ) {
+        mergedBySessionName.set(entry.sessionName, entry);
+      }
+    }
+    mergedBySessionName.set(params.sessionName, {
+      sessionName: params.sessionName,
+      resetEpochSeconds,
+    });
+    this.writeState(Array.from(mergedBySessionName.values()));
+  };
+
+  private readResetEntries = (): StoredResetEntry[] => {
+    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.resets;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredResetEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const resetEpochSeconds = storedEntry.resetEpochSeconds;
+      if (
+        typeof sessionName === 'string' &&
+        typeof resetEpochSeconds === 'number' &&
+        Number.isFinite(resetEpochSeconds)
+      ) {
+        entries.push({ sessionName, resetEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeState = (resets: StoredResetEntry[]): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporaryPath, JSON.stringify({ resets }));
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}

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

@@ -1,7 +1,10 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { FileSystemSubAgentLivenessResolver } from './FileSystemSubAgentLivenessResolver';
+import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
+import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
 
 describe('FileSystemSubAgentLivenessResolver', () => {
   let runtimeRoot: string;
@@ -40,6 +43,20 @@ describe('FileSystemSubAgentLivenessResolver', () => {
     expect(result).toEqual(new Set(['a70a08e0587d6f484', 'ad5d15d239d7e72e8']));
   });
 
+  it('returns only the leading agent id token of each record line', async () => {
+    writeRunningFile(
+      'ad3d5702d1339492e impl:redcircle-only-tag-format (no branch)\naf19c02b4c3a5d6e7 chore:board-sync i1300-record-parsing\n',
+    );
+    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
+
+    const result = await resolver.resolveLiveSubAgentIds({
+      sessionName,
+      mainTranscriptPath,
+    });
+
+    expect(result).toEqual(new Set(['ad3d5702d1339492e', 'af19c02b4c3a5d6e7']));
+  });
+
   it('returns an empty set when the running file exists but lists no ids', async () => {
     writeRunningFile('\n   \n');
     const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
@@ -85,3 +102,80 @@ describe('FileSystemSubAgentLivenessResolver', () => {
     expect(result).toBeNull();
   });
 });
+
+describe('running-subagents record agent id contract with TranscriptSessionSubAgentActivityRepository', () => {
+  const cwdSlug = '-home-user-worktrees-issue-1300';
+  const sessionUuid = 'c0f1a2b3-4d5e-6f70-8192-a3b4c5d6e7f8';
+  const sessionName = 'https_//github_com/owner/repo/issues/1300';
+  const liveAgentId = 'ad3d5702d1339492e';
+  const now = new Date('2026-07-28T12:00:00.000Z');
+  const emptyProcessLister: SubAgentProcessLister = {
+    listProcesses: async () => [],
+  };
+  let runtimeRoot: string;
+  let transcriptRoot: string;
+  let mainTranscriptPath: string;
+
+  beforeEach(() => {
+    runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-live-rt-'));
+    transcriptRoot = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'subagent-live-tx-'),
+    );
+    mainTranscriptPath = path.join(
+      transcriptRoot,
+      cwdSlug,
+      `${sessionUuid}.jsonl`,
+    );
+    fs.mkdirSync(path.dirname(mainTranscriptPath), { recursive: true });
+    fs.writeFileSync(mainTranscriptPath, '', 'utf8');
+  });
+
+  afterEach(() => {
+    fs.rmSync(runtimeRoot, { force: true, recursive: true });
+    fs.rmSync(transcriptRoot, { force: true, recursive: true });
+  });
+
+  it('keeps a sub-agent whose id is recorded together with its label on one line', async () => {
+    const runningDirectory = path.join(runtimeRoot, cwdSlug, sessionUuid);
+    fs.mkdirSync(runningDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(runningDirectory, 'running-subagents.txt'),
+      `${liveAgentId} impl:subagent-liveness-record-parsing (no branch)\n`,
+      'utf8',
+    );
+    const subAgentsDirectory = path.join(
+      transcriptRoot,
+      cwdSlug,
+      sessionUuid,
+      'subagents',
+    );
+    fs.mkdirSync(subAgentsDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(subAgentsDirectory, `agent-${liveAgentId}.jsonl`),
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: '2026-07-28T11:00:00.000Z',
+        message: {
+          stop_reason: 'tool_use',
+          content: [{ type: 'tool_use', name: 'Read', input: {} }],
+        },
+      }),
+      'utf8',
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      new FileSystemSubAgentTranscriptDirectoryResolver(transcriptRoot),
+      emptyProcessLister,
+      now,
+      new FileSystemSubAgentLivenessResolver(runtimeRoot),
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      new Map([[sessionName, mainTranscriptPath]]),
+    );
+
+    expect(result.get(sessionName)?.map((activity) => activity.label)).toEqual([
+      `agent-${liveAgentId}`,
+    ]);
+  });
+});

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts

@@ -25,9 +25,9 @@ export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResol
     }
     const liveIds = new Set<string>();
     for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed.length > 0) {
-        liveIds.add(trimmed);
+      const agentId = line.trim().split(/\s+/)[0];
+      if (agentId.length > 0) {
+        liveIds.add(agentId);
       }
     }
     return liveIds;