github-issue-tower-defence-management 1.122.2 → 1.122.4

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
 import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
+import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -23,9 +24,18 @@ const parseEpochSeconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : Math.floor(parsed / 1000);
 };
 
+const PENDING_TOOL_COMMAND_FRAGMENT_LENGTH = 60;
+
+export const normalizeCommandFragment = (command: string): string =>
+  command
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, PENDING_TOOL_COMMAND_FRAGMENT_LENGTH);
+
 type ParsedTranscript = {
   firstEntryEpochSeconds: number | null;
   lastEntryIndicatesCompletion: boolean;
+  pendingToolCommands: string[];
 };
 
 const readContentBlocks = (
@@ -65,9 +75,33 @@ const entryIndicatesCompletion = (entry: Record<string, unknown>): boolean => {
   return false;
 };
 
+const entryPendingToolCommands = (entry: Record<string, unknown>): string[] => {
+  const type = readString(entry, 'type');
+  const message = entry.message;
+  if (type !== 'assistant' || !isRecord(message)) {
+    return [];
+  }
+  const commands: string[] = [];
+  for (const block of readContentBlocks(message)) {
+    if (readString(block, 'type') !== 'tool_use') {
+      continue;
+    }
+    const input = block.input;
+    if (!isRecord(input)) {
+      continue;
+    }
+    const command = readString(input, 'command');
+    if (command !== null && command.trim().length > 0) {
+      commands.push(command);
+    }
+  }
+  return commands;
+};
+
 const parseTranscript = (content: string): ParsedTranscript => {
   let firstEntryEpochSeconds: number | null = null;
   let lastEntryIndicatesCompletion = false;
+  let pendingToolCommands: string[] = [];
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
     if (trimmed.length === 0) {
@@ -88,9 +122,14 @@ const parseTranscript = (content: string): ParsedTranscript => {
     }
     if (isRecord(parsed.message)) {
       lastEntryIndicatesCompletion = entryIndicatesCompletion(parsed);
+      pendingToolCommands = entryPendingToolCommands(parsed);
     }
   }
-  return { firstEntryEpochSeconds, lastEntryIndicatesCompletion };
+  return {
+    firstEntryEpochSeconds,
+    lastEntryIndicatesCompletion,
+    pendingToolCommands,
+  };
 };
 
 const clampToZero = (value: number): number => (value > 0 ? value : 0);
@@ -98,6 +137,7 @@ const clampToZero = (value: number): number => (value > 0 ? value : 0);
 export class TranscriptSessionSubAgentActivityRepository implements SessionSubAgentActivityRepository {
   constructor(
     private readonly directoryResolver: SubAgentTranscriptDirectoryResolver,
+    private readonly processLister: SubAgentProcessLister,
     private readonly now: Date,
   ) {}
 
@@ -107,6 +147,16 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
   ): Promise<Map<string, SubAgentActivity[]>> => {
     const result = new Map<string, SubAgentActivity[]>();
     const nowEpochSeconds = Math.floor(this.now.getTime() / 1000);
+    let normalizedProcessCommandLines: string[] | null = null;
+    const loadNormalizedProcessCommandLines = async (): Promise<string[]> => {
+      if (normalizedProcessCommandLines === null) {
+        const processes = await this.processLister.listProcesses();
+        normalizedProcessCommandLines = processes.map((process) =>
+          process.commandLine.replace(/\s+/g, ' ').trim(),
+        );
+      }
+      return normalizedProcessCommandLines;
+    };
     for (const sessionName of sessionNames) {
       const mainTranscriptPath =
         transcriptPathBySessionName.get(sessionName) ?? null;
@@ -117,7 +167,11 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       if (directory === null) {
         continue;
       }
-      const activities = this.collectActivities(directory, nowEpochSeconds);
+      const activities = await this.collectActivities(
+        directory,
+        nowEpochSeconds,
+        loadNormalizedProcessCommandLines,
+      );
       if (activities.length > 0) {
         result.set(sessionName, activities);
       }
@@ -125,10 +179,11 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return result;
   };
 
-  private collectActivities = (
+  private collectActivities = async (
     directory: string,
     nowEpochSeconds: number,
-  ): SubAgentActivity[] => {
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<SubAgentActivity[]> => {
     let entries: fs.Dirent[];
     try {
       entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -142,7 +197,12 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
         continue;
       }
       const filePath = path.join(directory, fileName);
-      const activity = this.toActivity(filePath, fileName, nowEpochSeconds);
+      const activity = await this.toActivity(
+        filePath,
+        fileName,
+        nowEpochSeconds,
+        loadNormalizedProcessCommandLines,
+      );
       if (activity !== null) {
         activities.push(activity);
       }
@@ -150,11 +210,12 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return activities;
   };
 
-  private toActivity = (
+  private toActivity = async (
     filePath: string,
     fileName: string,
     nowEpochSeconds: number,
-  ): SubAgentActivity | null => {
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<SubAgentActivity | null> => {
     let content: string;
     let stats: fs.Stats;
     try {
@@ -178,6 +239,29 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       label: fileName.replace(/\.jsonl$/, ''),
       silentSeconds,
       runningSeconds,
+      waitingOnExternalProcess: await this.hasLiveMatchingProcess(
+        transcript.pendingToolCommands,
+        loadNormalizedProcessCommandLines,
+      ),
     };
   };
+
+  private hasLiveMatchingProcess = async (
+    pendingToolCommands: string[],
+    loadNormalizedProcessCommandLines: () => Promise<string[]>,
+  ): Promise<boolean> => {
+    if (pendingToolCommands.length === 0) {
+      return false;
+    }
+    const fragments = pendingToolCommands
+      .map(normalizeCommandFragment)
+      .filter((fragment) => fragment.length > 0);
+    if (fragments.length === 0) {
+      return false;
+    }
+    const processCommandLines = await loadNormalizedProcessCommandLines();
+    return fragments.some((fragment) =>
+      processCommandLines.some((commandLine) => commandLine.includes(fragment)),
+    );
+  };
 }

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -593,6 +593,92 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('getCachedProject', () => {
+    it('returns the daemon-cached project without any GraphQL project load', async () => {
+      const { repository, localStorageCacheRepository, projectRepository } =
+        createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildTestProject('cached-project');
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [],
+      });
+
+      const result = await repository.getCachedProject('cached-project');
+
+      expect(result).toEqual(cachedProject);
+      expect(localStorageCacheRepository.getSingle).toHaveBeenCalledWith(
+        'allIssues-cached-project',
+      );
+      expect(projectRepository.getProject).not.toHaveBeenCalled();
+    });
+
+    it('returns null on a cache miss so the caller can fall back to GraphQL', async () => {
+      const { repository, localStorageCacheRepository, projectRepository } =
+        createApiV3CheerioRestIssueRepository();
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+
+      const result = await repository.getCachedProject('missing-project');
+
+      expect(result).toBeNull();
+      expect(projectRepository.getProject).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updateNextActionDate', () => {
+    const projectWithNextActionDate = (): Project => ({
+      ...buildTestProject('nad-project'),
+      nextActionDate: { name: 'Next Action Date', fieldId: 'nad-field' },
+    });
+
+    it('uses the provided project item id and skips the GraphQL item fetch', async () => {
+      const { repository, graphqlProjectItemRepository } =
+        createApiV3CheerioRestIssueRepository();
+      graphqlProjectItemRepository.updateProjectField.mockResolvedValue();
+
+      await repository.updateNextActionDate(
+        'https://github.com/o/r/issues/1',
+        projectWithNextActionDate(),
+        new Date('2026-07-20T00:00:00.000Z'),
+        'given-item-id',
+      );
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemByUrl,
+      ).not.toHaveBeenCalled();
+      expect(
+        graphqlProjectItemRepository.updateProjectField,
+      ).toHaveBeenCalledWith('nad-project', 'nad-field', 'given-item-id', {
+        date: '2026-07-20',
+      });
+    });
+
+    it('falls back to fetchProjectItemByUrl when no project item id is provided', async () => {
+      const { repository, graphqlProjectItemRepository } =
+        createApiV3CheerioRestIssueRepository();
+      graphqlProjectItemRepository.updateProjectField.mockResolvedValue();
+      graphqlProjectItemRepository.fetchProjectItemByUrl.mockResolvedValue(
+        buildProjectItem('https://github.com/o/r/issues/1', 'fallback'),
+      );
+
+      await repository.updateNextActionDate(
+        'https://github.com/o/r/issues/1',
+        projectWithNextActionDate(),
+        new Date('2026-07-20T00:00:00.000Z'),
+      );
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemByUrl,
+      ).toHaveBeenCalledWith('https://github.com/o/r/issues/1', 'nad-project');
+      expect(
+        graphqlProjectItemRepository.updateProjectField,
+      ).toHaveBeenCalledWith('nad-project', 'nad-field', 'item-fallback', {
+        date: '2026-07-20',
+      });
+    });
+  });
+
   describe('setDependedIssueUrl', () => {
     const projectWithDependedIssueUrlField = {
       ...mock<Project>(),

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -680,6 +680,25 @@ export class ApiV3CheerioRestIssueRepository
     };
   };
 
+  // Reads the Project (status/story option ids and field ids) that the TDPM
+  // daemon persisted into the `allIssues-${projectId}` cache, without any
+  // GraphQL call. Returns null on cache miss so callers can fall back to a
+  // GraphQL project load only when the daemon has not populated the cache yet.
+  getCachedProject = async (
+    projectId: Project['id'],
+  ): Promise<Project | null> => {
+    const raw = await this.localStorageCacheRepository.getSingle(
+      `allIssues-${projectId}`,
+    );
+    if (typeof raw !== 'object' || raw === null || !('project' in raw)) {
+      return null;
+    }
+    if (!typia.is<Project>(raw.project)) {
+      return null;
+    }
+    return raw.project;
+  };
+
   private toDateString = (date: Date): string =>
     `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`;
 
@@ -855,22 +874,30 @@ export class ApiV3CheerioRestIssueRepository
     issueUrl: string,
     project: Project,
     date: Date,
+    projectItemId?: string,
   ): Promise<void> => {
     if (!project.nextActionDate) {
       return;
     }
-    const projectItem =
-      await this.graphqlProjectItemRepository.fetchProjectItemByUrl(
-        issueUrl,
-        project.id,
-      );
-    if (!projectItem) {
+    // When the caller already knows the project item id (e.g. the console,
+    // which receives it in the request body), use it directly and skip the
+    // GraphQL fetchProjectItemByUrl lookup. Fall back to the lookup only when
+    // no id was supplied, preserving the original behavior for other callers.
+    const itemId =
+      projectItemId ??
+      (
+        await this.graphqlProjectItemRepository.fetchProjectItemByUrl(
+          issueUrl,
+          project.id,
+        )
+      )?.id;
+    if (!itemId) {
       return;
     }
     return this.graphqlProjectItemRepository.updateProjectField(
       project.id,
       project.nextActionDate.fieldId,
-      projectItem.id,
+      itemId,
       { date: date.toISOString().split('T')[0] },
     );
   };

package/src/domain/entities/LiveSessionActivitySnapshot.ts

@@ -2,6 +2,7 @@ export type SubAgentActivity = {
   label: string;
   silentSeconds: number;
   runningSeconds: number;
+  waitingOnExternalProcess: boolean;
 };
 
 export type LiveSessionActivitySnapshot = {

package/src/domain/usecases/DefaultSilentSessionMessageComposer.test.ts

@@ -1,11 +1,6 @@
 import { DefaultSilentSessionMessageComposer } from './DefaultSilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
-const THRESHOLDS = {
-  subAgentSilentThresholdSeconds: 300,
-  subAgentRunningThresholdSeconds: 900,
-};
-
 describe('DefaultSilentSessionMessageComposer', () => {
   const composer = new DefaultSilentSessionMessageComposer();
 
@@ -15,10 +10,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('embeds the reminder sentinel in the sub-agent section', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
   });
 
@@ -116,10 +117,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('emits a distinct idle message for a sub-agent that is only output-idle', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('sub-process-idle');
     expect(section).toContain('no output for 6m');
     expect(section).toContain('restart, hand off, or replace it');
@@ -128,10 +136,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('presents the system-detected idle duration as the authoritative signal in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       "The system has already detected, from each sub-process's last tool activity, that it has produced no output for about the minutes shown below.",
     );
@@ -142,10 +157,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('forbids speculation and dismissal without evidence in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Around five minutes of silence is a real warning of a possible hang',
     );
@@ -155,10 +177,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires a concrete cause-check covering recent activity and external-dependency waiting in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain(
       'a very recent push or commit, or output from any nested sub-processes this sub-process itself started',
@@ -175,26 +204,34 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires logging the investigation result even though owner notification is not required', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Owner notification is not required, but you MUST output your investigation result in this session so it remains as a log.',
     );
   });
 
   it('emits a distinct long-running message for a sub-agent that has only run too long', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).toContain('sub-process-long');
     expect(section).toContain('running for 20m');
     expect(section).toContain('infinite loop');
@@ -209,25 +246,32 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('does not foreground the short idle time in the long-running message', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).not.toContain('no output for');
     expect(section).not.toContain('silent for');
   });
 
   it('emits both distinct messages for a sub-agent matching both conditions, kept separate', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-both', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-both',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain('no output for 6m');
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain('running for 20m');
@@ -238,13 +282,24 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('groups each sub-agent under the condition it matched', () => {
-    const section = composer.composeSubAgentSection(
-      [
-        { label: 'idle-only', silentSeconds: 360, runningSeconds: 60 },
-        { label: 'long-only', silentSeconds: 10, runningSeconds: 960 },
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'idle-only',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
       ],
-      THRESHOLDS,
-    );
+      longRunningSubAgents: [
+        {
+          label: 'long-only',
+          silentSeconds: 10,
+          runningSeconds: 960,
+          waitingOnExternalProcess: false,
+        },
+      ],
+    });
     const [idleSection, longRunningSection] = section.split('\n\n');
     expect(idleSection).toContain('idle-only');
     expect(idleSection).not.toContain('long-only');
@@ -254,10 +309,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
 
   it('does not contain any host-specific or internal identifiers', () => {
     const mainSection = composer.composeMainStalledSection(600);
-    const subSection = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const subSection = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     const combined = `${mainSection}\n${subSection}`.toLowerCase();
     expect(combined).not.toContain('claude');
     expect(combined).not.toContain('take ownership');

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -1,7 +1,7 @@
 import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
 import {
   SilentSessionMessageComposer,
-  SubAgentStallThresholds,
+  SubAgentStallSections,
 } from './adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
@@ -74,24 +74,15 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
   };
 
-  composeSubAgentSection = (
-    subAgents: SubAgentActivity[],
-    thresholds: SubAgentStallThresholds,
-  ): string => {
-    const idleSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
-    );
-    const longRunningSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
-    );
+  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
     const sections: string[] = [];
-    if (idleSubAgents.length > 0) {
-      sections.push(composeIdleSubAgentSection(idleSubAgents));
+    if (stallSections.idleSubAgents.length > 0) {
+      sections.push(composeIdleSubAgentSection(stallSections.idleSubAgents));
     }
-    if (longRunningSubAgents.length > 0) {
-      sections.push(composeLongRunningSubAgentSection(longRunningSubAgents));
+    if (stallSections.longRunningSubAgents.length > 0) {
+      sections.push(
+        composeLongRunningSubAgentSection(stallSections.longRunningSubAgents),
+      );
     }
     return sections.join('\n\n');
   };