github-issue-tower-defence-management 1.173.2 → 1.174.0

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

@@ -69,6 +69,7 @@ import { ProxyRateLimitCacheRepository } from '../../repositories/ProxyRateLimit
 import { UpdateRateLimitCacheUseCase } from '../../../domain/usecases/UpdateRateLimitCacheUseCase';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from '../../../domain/usecases/RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from '../../../domain/usecases/TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from '../../../domain/usecases/AgentDesignationLabelAdoptUseCase';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { ProjectRequiredFieldCreateUseCase } from '../../../domain/usecases/ProjectRequiredFieldCreateUseCase';
@@ -496,6 +497,11 @@ export class HandleScheduledEventUseCaseHandler {
         issueRepository,
         issueCommentRepository,
       );
+    const triagerApprovalDispatchUseCase = new TriagerApprovalDispatchUseCase(
+      projectRepository,
+      issueRepository,
+      issueCommentRepository,
+    );
     const agentDesignationLabelAdoptUseCase =
       new AgentDesignationLabelAdoptUseCase(projectRepository, issueRepository);
 
@@ -533,6 +539,7 @@ export class HandleScheduledEventUseCaseHandler {
       startPreparationUseCase,
       revertOrphanedPreparationUseCase,
       revertNotReadyReviewQueueIssueUseCase,
+      triagerApprovalDispatchUseCase,
       agentDesignationLabelAdoptUseCase,
       updateRateLimitCacheUseCase,
       dailySecurityScanUseCase,

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

@@ -79,6 +79,7 @@ const createSubAgentActivityRepository = (
       new NodeSubAgentProcessLister(localCommandRunner),
       now,
       new FileSystemSubAgentLivenessResolver(subAgentRuntimeRootDirectory),
+      subAgentRuntimeRootDirectory,
     );
   }
   return new ProcessListSessionSubAgentActivityRepository(

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

@@ -66,6 +66,44 @@ describe('relabelAttachmentMarkdown', () => {
 });
 
 describe('LocalCommandIssueAttachmentRepository', () => {
+  const resolveGithubToken = (): string => 'default-token';
+
+  it('should run the upload command with the github token resolved for the item url', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
+    const received: {
+      args: string[];
+      options: LocalCommandRunnerOptions | undefined;
+    }[] = [];
+    const runner: LocalCommandRunner = {
+      runCommand: async (_program, args, options) => {
+        received.push({ args, options });
+        return {
+          stdout:
+            '![attachment](https://github.com/user-attachments/assets/66666666-7777-8888-9999-000000000000)\n',
+          stderr: '',
+          exitCode: 0,
+        };
+      },
+    };
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      (issueOrPullRequestUrl) =>
+        issueOrPullRequestUrl.startsWith('https://github.com/acme/')
+          ? 'acme-token'
+          : 'other-token',
+      root,
+    );
+
+    await repository.uploadAttachment({
+      issueOrPullRequestUrl: 'https://github.com/acme/repo/issues/7',
+      fileName: 'screenshot.png',
+      content: new Uint8Array([1]),
+    });
+
+    expect(received).toHaveLength(1);
+    expect(received[0].options?.env).toEqual({ GH_TOKEN: 'acme-token' });
+  });
+
   it('should upload the written file and return the markdown the command printed', async () => {
     const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
     const received: { program: string; args: string[] }[] = [];
@@ -80,7 +118,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
         };
       },
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     const markdown = await repository.uploadAttachment({
       issueOrPullRequestUrl: 'https://github.com/owner/repo/issues/1',
@@ -107,7 +149,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
         exitCode: 1,
       }),
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     await expect(
       repository.uploadAttachment({
@@ -126,7 +172,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
     const runner: LocalCommandRunner = {
       runCommand: async () => ({ stdout: '\n', stderr: '', exitCode: 0 }),
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     await expect(
       repository.uploadAttachment({
@@ -136,71 +186,4 @@ describe('LocalCommandIssueAttachmentRepository', () => {
       }),
     ).rejects.toThrow(`${UPLOAD_COMMAND} returned no markdown`);
   });
-
-  it('should pass GH_TOKEN env resolved from the owner when resolveGithubToken is provided', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
-    const received: {
-      program: string;
-      args: string[];
-      options: LocalCommandRunnerOptions | undefined;
-    }[] = [];
-    const runner: LocalCommandRunner = {
-      runCommand: async (program, args, options) => {
-        received.push({ program, args, options });
-        return {
-          stdout:
-            '![screenshot](https://github.com/user-attachments/assets/abc)\n',
-          stderr: '',
-          exitCode: 0,
-        };
-      },
-    };
-    const resolveGithubToken = (owner: string): string => `token-for-${owner}`;
-    const repository = new LocalCommandIssueAttachmentRepository(
-      runner,
-      root,
-      resolveGithubToken,
-    );
-
-    await repository.uploadAttachment({
-      issueOrPullRequestUrl: 'https://github.com/meta-site/repo/issues/1',
-      fileName: 'screenshot.png',
-      content: new Uint8Array([1, 2, 3]),
-    });
-
-    expect(received).toHaveLength(1);
-    expect(received[0].options).toEqual({
-      env: { GH_TOKEN: 'token-for-meta-site' },
-    });
-  });
-
-  it('should pass undefined as third argument to runCommand when resolveGithubToken is not provided', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
-    const received: {
-      program: string;
-      args: string[];
-      options: LocalCommandRunnerOptions | undefined;
-    }[] = [];
-    const runner: LocalCommandRunner = {
-      runCommand: async (program, args, options) => {
-        received.push({ program, args, options });
-        return {
-          stdout:
-            '![screenshot](https://github.com/user-attachments/assets/abc)\n',
-          stderr: '',
-          exitCode: 0,
-        };
-      },
-    };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
-
-    await repository.uploadAttachment({
-      issueOrPullRequestUrl: 'https://github.com/owner/repo/issues/1',
-      fileName: 'screenshot.png',
-      content: new Uint8Array([1]),
-    });
-
-    expect(received).toHaveLength(1);
-    expect(received[0].options).toBeUndefined();
-  });
 });

package/src/adapter/repositories/LocalCommandIssueAttachmentRepository.ts

@@ -9,6 +9,10 @@ import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/Loc
 
 export const UPLOAD_COMMAND = 'upload-file-to-gh-issue';
 
+export type IssueAttachmentGithubTokenResolver = (
+  issueOrPullRequestUrl: string,
+) => string;
+
 export const ALLOWED_ATTACHMENT_EXTENSIONS = [
   '.png',
   '.jpg',
@@ -57,8 +61,8 @@ export const relabelAttachmentMarkdown = (
 export class LocalCommandIssueAttachmentRepository implements IssueAttachmentRepository {
   constructor(
     private readonly localCommandRunner: LocalCommandRunner,
+    private readonly resolveGithubToken: IssueAttachmentGithubTokenResolver,
     private readonly temporaryDirectoryRoot: string = tmpdir(),
-    private readonly resolveGithubToken?: (repositoryOwner: string) => string,
   ) {}
 
   async uploadAttachment(
@@ -73,21 +77,14 @@ export class LocalCommandIssueAttachmentRepository implements IssueAttachmentRep
     );
     try {
       await writeFile(filePath, request.content);
-      let commandOptions: { env: { GH_TOKEN: string } } | undefined;
-      if (this.resolveGithubToken !== undefined) {
-        const ownerMatch = request.issueOrPullRequestUrl.match(
-          /https:\/\/github\.com\/([A-Za-z0-9._-]+)\//,
-        );
-        if (ownerMatch !== null) {
-          commandOptions = {
-            env: { GH_TOKEN: this.resolveGithubToken(ownerMatch[1]) },
-          };
-        }
-      }
       const result = await this.localCommandRunner.runCommand(
         UPLOAD_COMMAND,
         [filePath, request.issueOrPullRequestUrl],
-        commandOptions,
+        {
+          env: {
+            GH_TOKEN: this.resolveGithubToken(request.issueOrPullRequestUrl),
+          },
+        },
       );
       if (result.exitCode !== 0) {
         throw new Error(

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

@@ -1529,4 +1529,146 @@ describe('TranscriptSessionSubAgentActivityRepository', () => {
       },
     ]);
   });
+
+  const outputFilePathFor = (sessionName: string, agentId: string): string => {
+    const mainTranscriptPath = mainTranscriptPathFor(sessionName);
+    const slug = path.basename(path.dirname(mainTranscriptPath));
+    const sid = path.basename(mainTranscriptPath, '.jsonl');
+    return path.join(rootDirectory, slug, sid, 'tasks', `${agentId}.output`);
+  };
+
+  const createOutputFile = (sessionName: string, agentId: string): void => {
+    const filePath = outputFilePathFor(sessionName, agentId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, '', 'utf8');
+  };
+
+  it('excludes a sub-agent whose output file is absent and whose id matches no running process when the liveness file is absent', async () => {
+    const sessionName = 'session-4161-ghost-agent';
+    const agentId = 'a4161dead00000001';
+    writeAgentTranscript(
+      sessionName,
+      agentId,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 600,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+      livenessResolverWith(null),
+      rootDirectory,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.size).toBe(0);
+  });
+
+  it('includes a sub-agent whose output file exists even when the liveness file is absent', async () => {
+    const sessionName = 'session-4161-live-output';
+    const agentId = 'a4161live00000002';
+    writeAgentTranscript(
+      sessionName,
+      agentId,
+      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
+      nowEpochSeconds - 600,
+    );
+    createOutputFile(sessionName, agentId);
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+      livenessResolverWith(null),
+      rootDirectory,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: `agent-${agentId}`,
+        silentSeconds: 600,
+        runningSeconds: 900,
+        waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
+      },
+    ]);
+  });
+
+  it('includes a sub-agent whose output file is absent but whose id appears in a running process command line when the liveness file is absent', async () => {
+    const sessionName = 'session-4161-live-process';
+    const agentId = 'a4161proc00000003';
+    writeAgentTranscript(
+      sessionName,
+      agentId,
+      pendingToolUseEntries('2026-06-27T11:45:00.000Z'),
+      nowEpochSeconds - 600,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      processListerWith([
+        {
+          commandLine: `/path/to/claude --session ${agentId} --task task.txt`,
+          elapsedSeconds: 600,
+        },
+      ]),
+      now,
+      livenessResolverWith(null),
+      rootDirectory,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: `agent-${agentId}`,
+        silentSeconds: 600,
+        runningSeconds: 900,
+        waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
+      },
+    ]);
+  });
+
+  it('emits no sub-agent entries when every transcript has no output file and no matching process and the liveness file is absent', async () => {
+    const sessionName = 'session-4161-all-absent';
+    const agentId1 = 'a4161none00000004';
+    const agentId2 = 'a4161none00000005';
+    writeAgentTranscript(
+      sessionName,
+      agentId1,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 900,
+    );
+    writeAgentTranscript(
+      sessionName,
+      agentId2,
+      pendingToolUseEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 900,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      emptyProcessLister(),
+      now,
+      livenessResolverWith(null),
+      rootDirectory,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName(
+      [sessionName],
+      transcriptMapFor([sessionName]),
+    );
+
+    expect(result.size).toBe(0);
+  });
 });

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -250,6 +250,7 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     private readonly processLister: SubAgentProcessLister,
     private readonly now: Date,
     private readonly livenessResolver: SubAgentLivenessResolver = alwaysIndeterminateLivenessResolver,
+    private readonly runtimeRootDirectory: string | null = null,
   ) {}
 
   listSubAgentActivitiesBySessionName = async (
@@ -290,6 +291,7 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
         terminalAgentIds,
         liveSubAgentIds,
         loadNormalizedProcessCommandLines,
+        mainTranscriptPath,
       );
       if (activities.length > 0) {
         result.set(sessionName, activities);
@@ -313,12 +315,34 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return parseTerminalAgentIds(content);
   };
 
+  private resolveOutputFilePath = (
+    mainTranscriptPath: string | null,
+    agentId: string,
+  ): string | null => {
+    if (this.runtimeRootDirectory === null || mainTranscriptPath === null) {
+      return null;
+    }
+    const slug = path.basename(path.dirname(mainTranscriptPath));
+    const sid = path.basename(mainTranscriptPath, '.jsonl');
+    if (slug.length === 0 || slug === '.' || sid.length === 0) {
+      return null;
+    }
+    return path.join(
+      this.runtimeRootDirectory,
+      slug,
+      sid,
+      'tasks',
+      `${agentId}.output`,
+    );
+  };
+
   private collectActivities = async (
     directory: string,
     nowEpochSeconds: number,
     terminalAgentIds: Set<string>,
     liveSubAgentIds: Set<string> | null,
     loadNormalizedProcessCommandLines: () => Promise<string[]>,
+    mainTranscriptPath: string | null,
   ): Promise<SubAgentActivity[]> => {
     let entries: fs.Dirent[];
     try {
@@ -339,6 +363,23 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       if (liveSubAgentIds !== null && !liveSubAgentIds.has(agentId)) {
         continue;
       }
+      if (liveSubAgentIds === null && this.runtimeRootDirectory !== null) {
+        const outputFilePath = this.resolveOutputFilePath(
+          mainTranscriptPath,
+          agentId,
+        );
+        const outputFileExists =
+          outputFilePath !== null && fs.existsSync(outputFilePath);
+        if (!outputFileExists) {
+          const processCommandLines = await loadNormalizedProcessCommandLines();
+          const appearsInProcess = processCommandLines.some((line) =>
+            line.includes(agentId),
+          );
+          if (!appearsInProcess) {
+            continue;
+          }
+        }
+      }
       const filePath = path.join(directory, fileName);
       const activity = await this.toActivity(
         filePath,

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

@@ -24,6 +24,7 @@ import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCa
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
@@ -125,6 +126,8 @@ describe('HandleScheduledEventUseCase', () => {
       mock<RevertOrphanedPreparationUseCase>();
     const mockRevertNotReadyReviewQueueIssueUseCase =
       mock<RevertNotReadyReviewQueueIssueUseCase>();
+    const mockTriagerApprovalDispatchUseCase =
+      mock<TriagerApprovalDispatchUseCase>();
     const mockAgentDesignationLabelAdoptUseCase =
       mock<AgentDesignationLabelAdoptUseCase>();
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
@@ -156,6 +159,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
       mockRevertNotReadyReviewQueueIssueUseCase,
+      mockTriagerApprovalDispatchUseCase,
       mockAgentDesignationLabelAdoptUseCase,
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
@@ -236,6 +240,29 @@ describe('HandleScheduledEventUseCase', () => {
       });
     });
 
+    it('should call TriagerApprovalDispatchUseCase with project URL', async () => {
+      const input = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+      };
+
+      await useCase.run(input);
+      expect(mockTriagerApprovalDispatchUseCase.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectUrl: 'https://github.com/test-org/test-project',
+        }),
+      );
+    });
+
     it('should return null and skip all processing when disabled is true', async () => {
       const input = {
         projectName: 'test-project',

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -28,6 +28,8 @@ import {
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
+import { isRecord } from './isRecord';
 import { resolveLabelsAsLlmAgentName } from './resolveLabelsAsLlmAgentName';
 import { resolveAllowedIssueAuthors } from './resolveAllowedIssueAuthors';
 import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
@@ -64,9 +66,6 @@ const isTransientApiError = (error: Error): boolean => {
 const TRANSIENT_NETWORK_ERROR_CODE_PATTERN =
   /\b(ECONNRESET|ECONNREFUSED|ECONNABORTED|ETIMEDOUT|EPIPE|ENOTFOUND|EAI_AGAIN|ERR_NETWORK|ERR_SOCKET_CONNECTION_TIMEOUT)\b/;
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
 const extractHttpStatusFromError = (error: Error): number | null => {
   if (!isRecord(error)) {
     return null;
@@ -137,6 +136,7 @@ export class HandleScheduledEventUseCase {
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
+    readonly triagerApprovalDispatchUseCase: TriagerApprovalDispatchUseCase,
     readonly agentDesignationLabelAdoptUseCase: AgentDesignationLabelAdoptUseCase,
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
@@ -437,6 +437,10 @@ ${JSON.stringify(e)}
       changeTargetPathAliases: input.changeTargetPathAliases,
       allowedIssueAuthors,
     });
+    await this.triagerApprovalDispatchUseCase.run({
+      projectUrl: input.projectUrl,
+      allowedIssueAuthors,
+    });
     if (this.dailySecurityScanUseCase !== null && input.dailySecurityScan) {
       await this.dailySecurityScanUseCase.run({
         targetDates: targetDateTimes,