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

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

@@ -1,285 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
-  defaultSilentSessionHubTaskStatusCacheFilePath,
-  FileSystemSilentSessionHubTaskStatusCacheRepository,
-} from './FileSystemSilentSessionHubTaskStatusCacheRepository';
-
-describe('FileSystemSilentSessionHubTaskStatusCacheRepository', () => {
-  let rootDirectory: string;
-  let stateFilePath: string;
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'silent-session-hub-task-status-'),
-    );
-    stateFilePath = path.join(
-      rootDirectory,
-      'silent-session-hub-task-status.json',
-    );
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDirectory, { force: true, recursive: true });
-  });
-
-  const issueAlpha = 'https://github.com/HiromiShikata/repo/issues/100';
-  const issueBravo = 'https://github.com/HiromiShikata/repo/issues/200';
-
-  it('round-trips a saved status so the next cycle reads it back', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-    const now = new Date('2026-06-26T00:00:00Z');
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now,
-    });
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toEqual({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
-    });
-  });
-
-  it('preserves a null project status across a round-trip', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-    const now = new Date('2026-06-26T00:00:00Z');
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'CLOSED',
-      status: null,
-      now,
-    });
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toEqual({
-      url: issueAlpha,
-      state: 'CLOSED',
-      status: null,
-      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
-    });
-  });
-
-  it('returns null when no status has been recorded for the url', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toBeNull();
-  });
-
-  it('returns null when no state file exists yet', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      path.join(rootDirectory, 'missing.json'),
-    );
-
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toBeNull();
-  });
-
-  it('returns the most recently recorded status when a url is saved again', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T00:00:00Z'),
-    });
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'CLOSED',
-      status: 'Done',
-      now: new Date('2026-06-26T00:01:00Z'),
-    });
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded?.state).toBe('CLOSED');
-    expect(loaded?.status).toBe('Done');
-  });
-
-  it('preserves another url recorded by a concurrent run when saving a different url', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T00:00:00Z'),
-    });
-    await repository.saveHubTaskStatus({
-      url: issueBravo,
-      state: 'CLOSED',
-      status: 'Done',
-      now: new Date('2026-06-26T00:00:30Z'),
-    });
-
-    expect(
-      (await repository.loadHubTaskStatus({ url: issueAlpha }))?.state,
-    ).toBe('OPEN');
-    expect(
-      (await repository.loadHubTaskStatus({ url: issueBravo }))?.state,
-    ).toBe('CLOSED');
-  });
-
-  it('drops a stored entry that has aged beyond the retention window on the next save', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-      60 * 60,
-    );
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T00:00:00Z'),
-    });
-    await repository.saveHubTaskStatus({
-      url: issueBravo,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T01:30:00Z'),
-    });
-
-    const persisted: unknown = JSON.parse(
-      fs.readFileSync(stateFilePath, 'utf8'),
-    );
-    expect(persisted).toEqual({
-      hubTaskStatuses: [
-        {
-          url: issueBravo,
-          state: 'OPEN',
-          status: 'In tmux',
-          recordedEpochSeconds: Math.floor(
-            new Date('2026-06-26T01:30:00Z').getTime() / 1000,
-          ),
-        },
-      ],
-    });
-  });
-
-  it('treats a corrupt state file as no recorded status', async () => {
-    fs.writeFileSync(stateFilePath, 'not valid json');
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toBeNull();
-  });
-
-  it('ignores a malformed stored entry that lacks a valid state', async () => {
-    fs.writeFileSync(
-      stateFilePath,
-      JSON.stringify({
-        hubTaskStatuses: [
-          {
-            url: issueAlpha,
-            state: 'UNKNOWN',
-            status: 'In tmux',
-            recordedEpochSeconds: 1,
-          },
-        ],
-      }),
-    );
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
-
-    expect(loaded).toBeNull();
-  });
-
-  it('creates the parent directory when the configured path does not exist yet', async () => {
-    const nestedPath = path.join(rootDirectory, 'nested', 'dir', 'state.json');
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      nestedPath,
-    );
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T00:00:00Z'),
-    });
-
-    expect(fs.existsSync(nestedPath)).toBe(true);
-  });
-
-  it('writes atomically by renaming a temp file into place leaving no temp file behind', async () => {
-    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
-      stateFilePath,
-    );
-
-    await repository.saveHubTaskStatus({
-      url: issueAlpha,
-      state: 'OPEN',
-      status: 'In tmux',
-      now: new Date('2026-06-26T00:00:00Z'),
-    });
-
-    const leftoverTempFiles = fs
-      .readdirSync(rootDirectory)
-      .filter((name) => name.includes('.tmp'));
-    expect(leftoverTempFiles).toEqual([]);
-    expect(fs.existsSync(stateFilePath)).toBe(true);
-  });
-
-  it('exposes the default retention window as a named constant', () => {
-    expect(DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
-  });
-});
-
-describe('defaultSilentSessionHubTaskStatusCacheFilePath', () => {
-  const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-
-  afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-      delete process.env.XDG_CACHE_HOME;
-    } else {
-      process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-  });
-
-  it('places the state file at tdpm/silent-session-hub-task-status.json below XDG_CACHE_HOME when set', () => {
-    process.env.XDG_CACHE_HOME = '/custom/cache';
-
-    expect(defaultSilentSessionHubTaskStatusCacheFilePath()).toBe(
-      '/custom/cache/tdpm/silent-session-hub-task-status.json',
-    );
-  });
-
-  it('places the state file at tdpm/silent-session-hub-task-status.json below the home cache directory when XDG_CACHE_HOME is absent', () => {
-    delete process.env.XDG_CACHE_HOME;
-
-    expect(defaultSilentSessionHubTaskStatusCacheFilePath()).toBe(
-      path.join(
-        os.homedir(),
-        '.cache',
-        'tdpm',
-        'silent-session-hub-task-status.json',
-      ),
-    );
-  });
-});

package/src/adapter/repositories/FileSystemSilentSessionHubTaskStatusCacheRepository.ts

@@ -1,119 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { Issue } from '../../domain/entities/Issue';
-import {
-  SilentSessionHubTaskStatusCacheEntry,
-  SilentSessionHubTaskStatusCacheRepository,
-} from '../../domain/usecases/adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
-import { tdpmCacheDirectory } from './localStorageCacheDirectory';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const isIssueState = (value: unknown): value is Issue['state'] =>
-  value === 'OPEN' || value === 'CLOSED' || value === 'MERGED';
-
-export const DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS = 60 * 60;
-
-export const defaultSilentSessionHubTaskStatusCacheFilePath = (): string =>
-  path.join(tdpmCacheDirectory(), 'silent-session-hub-task-status.json');
-
-export class FileSystemSilentSessionHubTaskStatusCacheRepository implements SilentSessionHubTaskStatusCacheRepository {
-  constructor(
-    private readonly stateFilePath: string = defaultSilentSessionHubTaskStatusCacheFilePath(),
-    private readonly retentionWindowSeconds: number = DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
-  ) {}
-
-  loadHubTaskStatus = async (params: {
-    url: string;
-  }): Promise<SilentSessionHubTaskStatusCacheEntry | null> => {
-    for (const entry of this.readEntries()) {
-      if (entry.url === params.url) {
-        return entry;
-      }
-    }
-    return null;
-  };
-
-  saveHubTaskStatus = async (params: {
-    url: string;
-    state: Issue['state'];
-    status: string | null;
-    now: Date;
-  }): Promise<void> => {
-    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
-    const oldestRetainedEpochSeconds =
-      recordedEpochSeconds - this.retentionWindowSeconds;
-    const mergedByUrl = new Map<string, SilentSessionHubTaskStatusCacheEntry>();
-    for (const entry of this.readEntries()) {
-      if (
-        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
-        entry.url !== params.url
-      ) {
-        mergedByUrl.set(entry.url, entry);
-      }
-    }
-    mergedByUrl.set(params.url, {
-      url: params.url,
-      state: params.state,
-      status: params.status,
-      recordedEpochSeconds,
-    });
-    this.writeEntries(Array.from(mergedByUrl.values()));
-  };
-
-  private readEntries = (): SilentSessionHubTaskStatusCacheEntry[] => {
-    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.hubTaskStatuses;
-    if (!Array.isArray(storedEntries)) {
-      return [];
-    }
-    const entries: SilentSessionHubTaskStatusCacheEntry[] = [];
-    for (const storedEntry of storedEntries) {
-      if (!isRecord(storedEntry)) {
-        continue;
-      }
-      const url = storedEntry.url;
-      const state = storedEntry.state;
-      const status = storedEntry.status;
-      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
-      if (
-        typeof url === 'string' &&
-        isIssueState(state) &&
-        (typeof status === 'string' || status === null) &&
-        typeof recordedEpochSeconds === 'number' &&
-        Number.isFinite(recordedEpochSeconds)
-      ) {
-        entries.push({ url, state, status, recordedEpochSeconds });
-      }
-    }
-    return entries;
-  };
-
-  private writeEntries = (
-    entries: SilentSessionHubTaskStatusCacheEntry[],
-  ): void => {
-    const directory = path.dirname(this.stateFilePath);
-    fs.mkdirSync(directory, { recursive: true });
-    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
-    fs.writeFileSync(
-      temporaryPath,
-      JSON.stringify({ hubTaskStatuses: entries }),
-    );
-    fs.renameSync(temporaryPath, this.stateFilePath);
-  };
-}

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

@@ -1,237 +0,0 @@
-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;
-  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 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);
-
-    const result = await resolver.resolveLiveSubAgentIds({
-      sessionName,
-      mainTranscriptPath,
-    });
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('returns null when the runtime root exists and the session has no running file', async () => {
-    const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
-
-    const result = await resolver.resolveLiveSubAgentIds({
-      sessionName,
-      mainTranscriptPath,
-    });
-
-    expect(result).toBeNull();
-  });
-
-  it('returns null when the configured runtime root directory does not exist', async () => {
-    const resolver = new FileSystemSubAgentLivenessResolver(
-      path.join(runtimeRoot, 'absent-runtime-root'),
-    );
-
-    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();
-  });
-});
-
-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}`,
-    ]);
-  });
-
-  it('detects a working sub-agent when the runtime root exists and the session has no running-subagents record', async () => {
-    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-20T11: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)).toEqual([
-      {
-        label: `agent-${liveAgentId}`,
-        silentSeconds: 0,
-        runningSeconds: 694800,
-        waitingOnExternalProcess: false,
-        finishedResultUnconsumed: false,
-      },
-    ]);
-  });
-});

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts

@@ -1,57 +0,0 @@
-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 agentId = line.trim().split(/\s+/)[0];
-      if (agentId.length > 0) {
-        liveIds.add(agentId);
-      }
-    }
-    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,
-    );
-  };
-}