github-issue-tower-defence-management 1.126.2 → 1.127.0

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

@@ -25,6 +25,14 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     },
   });
 
+  const assistantEntryWithoutTimestamp = (): object => ({
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'no timestamp on this entry' }],
+    },
+  });
+
   const userEntry = (timestamp: string): object => ({
     type: 'user',
     timestamp,
@@ -37,6 +45,51 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     toolUseResult: { stdout: 'done', stderr: '' },
   });
 
+  const systemEntry = (timestamp: string): object => ({
+    type: 'system',
+    timestamp,
+    content: 'Compacting conversation history',
+  });
+
+  const assistantEntryWithToolUse = (
+    timestamp: string,
+    toolUseId: string,
+  ): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      stop_reason: 'tool_use',
+      content: [
+        { type: 'text', text: 'running a command' },
+        {
+          type: 'tool_use',
+          id: toolUseId,
+          name: 'Bash',
+          input: { command: 'sleep 590' },
+        },
+      ],
+    },
+  });
+
+  const toolResultUserEntry = (
+    timestamp: string,
+    toolUseId: string,
+  ): object => ({
+    type: 'user',
+    timestamp,
+    message: {
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: toolUseId,
+          content: 'done',
+        },
+      ],
+    },
+  });
+
   const untimestampedEntry = (): object => ({
     type: 'summary',
     summary: 'no timestamp on this entry',
@@ -52,11 +105,56 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     return filePath;
   };
 
-  it('returns the latest entry timestamp of any type as the last activity epoch', async () => {
+  it('returns the old last-assistant timestamp when recent system and tool entries follow it', async () => {
+    const transcriptPath = writeTranscript('thrashing.jsonl', [
+      assistantEntry('2026-06-27T01:00:00.000Z'),
+      systemEntry('2026-06-27T09:30:00.000Z'),
+      toolResultEntry('2026-06-27T09:45:00.000Z'),
+      systemEntry('2026-06-27T10:00:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['thrashing', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'thrashing',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T01:00:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('returns the recent timestamp when the latest assistant entry is recent', async () => {
+    const transcriptPath = writeTranscript('working.jsonl', [
+      userEntry('2026-06-27T09:00:00.000Z'),
+      assistantEntry('2026-06-27T09:55:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['working', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'working',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T09:55:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('ignores a later user entry and returns the last assistant timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      userEntry('2026-06-27T10:30:00.000Z'),
-      assistantEntry('2026-06-27T10:05:00.000Z'),
+      userEntry('2026-06-27T11:00:00.000Z'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -68,16 +166,41 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:30:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('advances the last activity time when a later user entry follows an assistant entry', async () => {
+  it('ignores a later tool_result entry and returns the last assistant timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      userEntry('2026-06-27T11:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:45:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('returns the last assistant entry timestamp when several entry types interleave', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T10:10:00.000Z'),
+      assistantEntry('2026-06-27T10:05:00.000Z'),
+      systemEntry('2026-06-27T10:40:00.000Z'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -89,16 +212,17 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T11:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('advances the last activity time when a tool_result entry is the latest entry', async () => {
+  it('falls back to the last assistant entry that has a parseable timestamp', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
-      toolResultEntry('2026-06-27T10:45:00.000Z'),
+      assistantEntryWithoutTimestamp(),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -110,8 +234,9 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:45:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -135,13 +260,29 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: false,
       },
     ]);
   });
 
-  it('resolves a transcript whose only entry is a non-assistant entry', async () => {
+  it('omits a transcript whose only entries are non-assistant entries', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       userEntry('2026-06-27T10:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:05:00.000Z'),
+      systemEntry('2026-06-27T10:10:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([]);
+  });
+
+  it('omits sessions whose transcript has no parseable timestamp', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      untimestampedEntry(),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
@@ -149,27 +290,51 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       new Map([['workbench', transcriptPath]]),
     );
 
+    expect(result).toEqual([]);
+  });
+
+  it('flags a session as waiting on a running tool when the last assistant tool_use has no matching tool_result', async () => {
+    const transcriptPath = writeTranscript('busy.jsonl', [
+      assistantEntry('2026-06-27T09:00:00.000Z'),
+      assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_running'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['busy', transcriptPath]]),
+    );
+
     expect(result).toEqual([
       {
-        sessionName: 'workbench',
+        sessionName: 'busy',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T09:01:00.000Z') / 1000,
         ),
+        hasInProgressToolCall: true,
       },
     ]);
   });
 
-  it('omits sessions whose transcript has no parseable timestamp', async () => {
-    const transcriptPath = writeTranscript('workbench.jsonl', [
-      untimestampedEntry(),
+  it('does not flag a session once the matching tool_result for its last tool_use is appended', async () => {
+    const transcriptPath = writeTranscript('completed.jsonl', [
+      assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_done'),
+      toolResultUserEntry('2026-06-27T09:05:00.000Z', 'toolu_done'),
     ]);
     const repository = new FileSystemSessionOutputActivityRepository();
 
     const result = await repository.listSessionOutputActivities(
-      new Map([['workbench', transcriptPath]]),
+      new Map([['completed', transcriptPath]]),
     );
 
-    expect(result).toEqual([]);
+    expect(result).toEqual([
+      {
+        sessionName: 'completed',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T09:01:00.000Z') / 1000,
+        ),
+        hasInProgressToolCall: false,
+      },
+    ]);
   });
 
   it('returns an empty list when no sessions are requested', async () => {

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -21,41 +21,54 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : parsed;
 };
 
-/**
- * Reads the last main-session activity time for each live session from its
- * already-resolved transcript path. Idle time is computed from the timestamp of
- * the latest entry of any kind (assistant text, owner replies, tool results, or
- * any other entry type) rather than from the transcript file modification time.
- * Because a session that is actively running tool calls keeps appending entries
- * such as `user` and `tool_result` even while it emits no assistant text, every
- * entry with a parseable timestamp counts as activity, so a working session is
- * not mistaken for a silent one.
- */
+const readContentBlocks = (
+  message: Record<string, unknown>,
+): Record<string, unknown>[] => {
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter(isRecord);
+};
+
+type TranscriptActivity = {
+  lastAssistantOutputEpochSeconds: number | null;
+  hasInProgressToolCall: boolean;
+};
+
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
     transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const lastOutputEpochSeconds =
-        this.readLastActivityEpochSeconds(transcriptPath);
-      if (lastOutputEpochSeconds !== null) {
-        activities.push({ sessionName, lastOutputEpochSeconds });
+      const { lastAssistantOutputEpochSeconds, hasInProgressToolCall } =
+        this.readTranscriptActivity(transcriptPath);
+      if (lastAssistantOutputEpochSeconds !== null) {
+        activities.push({
+          sessionName,
+          lastOutputEpochSeconds: lastAssistantOutputEpochSeconds,
+          hasInProgressToolCall,
+        });
       }
     }
     return activities;
   };
 
-  private readLastActivityEpochSeconds = (
+  private readTranscriptActivity = (
     transcriptPath: string,
-  ): number | null => {
+  ): TranscriptActivity => {
     let content: string;
     try {
       content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
-      return null;
+      return {
+        lastAssistantOutputEpochSeconds: null,
+        hasInProgressToolCall: false,
+      };
     }
-    let lastActivityEpochMs: number | null = null;
+    let lastAssistantOutputEpochMs: number | null = null;
+    const pendingToolUseIds = new Set<string>();
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -70,17 +83,37 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       if (!isRecord(parsed)) {
         continue;
       }
-      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
-      if (epochMs === null) {
+      const message = parsed.message;
+      if (readString(parsed, 'type') === 'assistant') {
+        const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
+        if (epochMs !== null) {
+          lastAssistantOutputEpochMs = epochMs;
+        }
+      }
+      if (!isRecord(message)) {
         continue;
       }
-      if (lastActivityEpochMs === null || epochMs > lastActivityEpochMs) {
-        lastActivityEpochMs = epochMs;
+      for (const block of readContentBlocks(message)) {
+        const blockType = readString(block, 'type');
+        if (blockType === 'tool_use') {
+          const toolUseId = readString(block, 'id');
+          if (toolUseId !== null) {
+            pendingToolUseIds.add(toolUseId);
+          }
+        } else if (blockType === 'tool_result') {
+          const toolUseId = readString(block, 'tool_use_id');
+          if (toolUseId !== null) {
+            pendingToolUseIds.delete(toolUseId);
+          }
+        }
       }
     }
-    if (lastActivityEpochMs === null) {
-      return null;
-    }
-    return Math.floor(lastActivityEpochMs / 1000);
+    return {
+      lastAssistantOutputEpochSeconds:
+        lastAssistantOutputEpochMs === null
+          ? null
+          : Math.floor(lastAssistantOutputEpochMs / 1000),
+      hasInProgressToolCall: pendingToolUseIds.size > 0,
+    };
   };
 }

package/src/domain/entities/LiveSessionActivitySnapshot.ts

@@ -8,6 +8,7 @@ export type SubAgentActivity = {
 export type LiveSessionActivitySnapshot = {
   sessionName: string;
   mainSilentSeconds: number | null;
+  mainHasInProgressToolCall: boolean;
   subAgents: SubAgentActivity[];
   unansweredOwnerCallAgeSeconds: number | null;
 };

package/src/domain/entities/LiveSessionOutputActivity.ts

@@ -1,4 +1,5 @@
 export type LiveSessionOutputActivity = {
   sessionName: string;
   lastOutputEpochSeconds: number;
+  hasInProgressToolCall: boolean;
 };

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

@@ -180,6 +180,101 @@ describe('AssignNoAssigneeIssueToManagerUseCase', () => {
       consoleErrorSpy.mockRestore();
     });
 
+    it('should assign only issues whose author is in autoAssignManagerAuthors', async () => {
+      const allowedIssue = {
+        ...basicIssue,
+        author: 'renovate[bot]',
+      };
+      const disallowedIssue = {
+        ...basicIssue,
+        author: 'human-author',
+      };
+
+      await useCase.run({
+        issues: [allowedIssue, disallowedIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+        autoAssignManagerAuthors: ['renovate[bot]'],
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [allowedIssue, ['manager1']],
+      ]);
+    });
+
+    it('should assign only listed authors in a mixed-author set', async () => {
+      const renovateIssue = {
+        ...basicIssue,
+        author: 'renovate[bot]',
+      };
+      const humanIssue = {
+        ...basicIssue,
+        author: 'human-author',
+      };
+      const dependabotIssue = {
+        ...basicIssue,
+        author: 'dependabot[bot]',
+      };
+
+      await useCase.run({
+        issues: [renovateIssue, humanIssue, dependabotIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+        autoAssignManagerAuthors: ['renovate[bot]', 'dependabot[bot]'],
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [renovateIssue, ['manager1']],
+        [dependabotIssue, ['manager1']],
+      ]);
+    });
+
+    it('should assign all unassigned issues when autoAssignManagerAuthors is null', async () => {
+      const firstIssue = {
+        ...basicIssue,
+        author: 'renovate[bot]',
+      };
+      const secondIssue = {
+        ...basicIssue,
+        author: 'human-author',
+      };
+
+      await useCase.run({
+        issues: [firstIssue, secondIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+        autoAssignManagerAuthors: null,
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [firstIssue, ['manager1']],
+        [secondIssue, ['manager1']],
+      ]);
+    });
+
+    it('should assign all unassigned issues when autoAssignManagerAuthors is an empty array', async () => {
+      const firstIssue = {
+        ...basicIssue,
+        author: 'renovate[bot]',
+      };
+      const secondIssue = {
+        ...basicIssue,
+        author: 'human-author',
+      };
+
+      await useCase.run({
+        issues: [firstIssue, secondIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+        autoAssignManagerAuthors: [],
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [firstIssue, ['manager1']],
+        [secondIssue, ['manager1']],
+      ]);
+    });
+
     it('should rethrow non-Error thrown values without logging', async () => {
       const failingIssue = {
         ...basicIssue,

package/src/domain/usecases/AssignNoAssigneeIssueToManagerUseCase.ts

@@ -11,14 +11,23 @@ export class AssignNoAssigneeIssueToManagerUseCase {
     issues: Issue[];
     manager: Member['name'];
     cacheUsed: boolean;
+    autoAssignManagerAuthors?: string[] | null;
   }): Promise<void> => {
     if (input.cacheUsed) {
       return;
     }
+    const authorAllowList =
+      input.autoAssignManagerAuthors &&
+      input.autoAssignManagerAuthors.length > 0
+        ? input.autoAssignManagerAuthors
+        : null;
     for (const issue of input.issues) {
       if (issue.assignees.length > 0 || issue.state !== 'OPEN') {
         continue;
       }
+      if (authorAllowList !== null && !authorAllowList.includes(issue.author)) {
+        continue;
+      }
       try {
         await this.issueRepository.updateAssigneeList(issue, [input.manager]);
       } catch (e) {

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -154,6 +154,7 @@ export class HandleScheduledEventUseCase {
     labelsAsLlmAgentName?: string[] | null;
     changeTargetPathAliases?: Record<string, string> | null;
     allowedIssueAuthors?: string[] | null;
+    autoAssignManagerAuthors?: string[] | null;
     startPreparation?: {
       defaultAgentName: string;
       defaultLlmModelName?: string | null;
@@ -549,6 +550,7 @@ ${JSON.stringify(e)}
       issues,
       manager: input.manager,
       cacheUsed,
+      autoAssignManagerAuthors: input.autoAssignManagerAuthors ?? null,
     });
     await this.updateIssueStatusByLabelUseCase.run({
       project,