github-issue-tower-defence-management 1.168.4 → 1.169.1

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

@@ -107,6 +107,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     requestChangesWithInlineComment: jest.Mock;
     setDependedIssueUrl: jest.Mock;
     setIssueAgentField: jest.Mock;
+    searchIssue: jest.Mock;
+    createNewIssue: jest.Mock;
   };
   let mockIssueCommentRepository: {
     getCommentsFromIssue: jest.Mock;
@@ -147,6 +149,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       requestChangesWithInlineComment: jest.fn().mockResolvedValue(undefined),
       setDependedIssueUrl: jest.fn(),
       setIssueAgentField: jest.fn().mockResolvedValue(undefined),
+      searchIssue: jest.fn().mockResolvedValue([]),
+      createNewIssue: jest.fn().mockResolvedValue(42),
     };
 
     mockIssueCommentRepository = {
@@ -3893,4 +3897,162 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       ).not.toHaveBeenCalled();
     });
   });
+
+  describe('when missingAgentName is provided', () => {
+    const issueUrl = 'https://github.com/user/repo/issues/1';
+    const taskIssueTitle = 'Register missing agent definition: impl';
+    const taskIssueUrl = 'https://github.com/user/repo/issues/42';
+
+    it('creates a task issue and sets depended issue URL when no existing open task issue exists', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        missingAgentName: 'impl',
+        sessionErrorLine:
+          "Error: Agent 'impl' not found at /path/agents/impl.md",
+      });
+
+      expect(mockIssueRepository.searchIssue).toHaveBeenCalledWith({
+        owner: 'user',
+        repositoryName: 'repo',
+        type: 'issue',
+        state: 'open',
+        title: taskIssueTitle,
+      });
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledWith(
+        'user',
+        'repo',
+        taskIssueTitle,
+        expect.stringContaining(issueUrl),
+        [],
+        [],
+      );
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledWith(
+        'user',
+        'repo',
+        taskIssueTitle,
+        expect.stringContaining('impl'),
+        [],
+        [],
+      );
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledWith(
+        'user',
+        'repo',
+        taskIssueTitle,
+        expect.stringContaining(
+          "Error: Agent 'impl' not found at /path/agents/impl.md",
+        ),
+        [],
+        [],
+      );
+      expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+        issueUrl,
+        mockProject,
+        taskIssueUrl,
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining('impl'),
+      );
+    });
+
+    it('reuses an existing open task issue and does not create a new one', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.searchIssue.mockResolvedValue([
+        {
+          url: taskIssueUrl,
+          title: taskIssueTitle,
+          number: '42',
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        missingAgentName: 'impl',
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+        issueUrl,
+        mockProject,
+        taskIssueUrl,
+      );
+    });
+
+    it('skips setDependedIssueUrl when project has no dependedIssueUrlSeparatedByComma field but still creates the task issue and returns to Awaiting Workspace', async () => {
+      const projectWithoutDependedField = createMockProject({
+        dependedIssueUrlSeparatedByComma: null,
+      });
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(
+        projectWithoutDependedField,
+      );
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        missingAgentName: 'impl',
+      });
+
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        projectWithoutDependedField,
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        'awaiting-workspace-id',
+      );
+    });
+
+    it('uses (not captured) as error line when sessionErrorLine is not provided', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        missingAgentName: 'impl',
+      });
+
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledWith(
+        'user',
+        'repo',
+        taskIssueTitle,
+        expect.stringContaining('(not captured)'),
+        [],
+        [],
+      );
+    });
+  });
 });

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -73,6 +73,8 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'requestChangesWithInlineComment'
       | 'setDependedIssueUrl'
       | 'setIssueAgentField'
+      | 'searchIssue'
+      | 'createNewIssue'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -100,6 +102,8 @@ export class NotifyFinishedIssuePreparationUseCase {
     labelsNotRequiringPullRequest?: string[] | null;
     changeTargetPathAliases?: Record<string, string> | null;
     agents?: string[] | null;
+    missingAgentName?: string | null;
+    sessionErrorLine?: string | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -143,6 +147,17 @@ export class NotifyFinishedIssuePreparationUseCase {
       );
     }
 
+    if (params.missingAgentName) {
+      await this.handleMissingAgentDefinition(
+        issue,
+        project,
+        awaitingWorkspaceStatusOption,
+        params.missingAgentName,
+        params.sessionErrorLine ?? null,
+      );
+      return;
+    }
+
     if (issue.dependedIssueUrls.length === 0) {
       try {
         const storyObjectMap =
@@ -363,6 +378,72 @@ export class NotifyFinishedIssuePreparationUseCase {
     );
   };
 
+  private handleMissingAgentDefinition = async (
+    issue: Issue,
+    project: Project,
+    awaitingWorkspaceStatusOption: { id: string },
+    missingAgentName: string,
+    sessionErrorLine: string | null,
+  ): Promise<void> => {
+    const taskIssueTitle = `Register missing agent definition: ${missingAgentName}`;
+
+    const searchResults = await this.issueRepository.searchIssue({
+      owner: issue.org,
+      repositoryName: issue.repo,
+      type: 'issue',
+      state: 'open',
+      title: taskIssueTitle,
+    });
+    const exactMatch = searchResults.find((i) => i.title === taskIssueTitle);
+
+    let taskIssueUrl: string;
+    if (exactMatch) {
+      taskIssueUrl = exactMatch.url;
+    } else {
+      const body = [
+        `The preparation worker for ${issue.url} failed because the agent definition \`${missingAgentName}\` was not found.`,
+        '',
+        `- Missing agent name: \`${missingAgentName}\``,
+        `- Failing item: ${issue.url}`,
+        `- Error: ${sessionErrorLine ?? '(not captured)'}`,
+      ].join('\n');
+      const issueNumber = await this.issueRepository.createNewIssue(
+        issue.org,
+        issue.repo,
+        taskIssueTitle,
+        body,
+        [],
+        [],
+      );
+      taskIssueUrl = `https://github.com/${issue.org}/${issue.repo}/issues/${issueNumber}`;
+    }
+
+    if (project.dependedIssueUrlSeparatedByComma) {
+      await this.issueRepository.setDependedIssueUrl(
+        issue.url,
+        project,
+        taskIssueUrl,
+      );
+    } else {
+      console.warn(
+        `dependedIssueUrlSeparatedByComma not configured; cannot block ${issue.url} via ${taskIssueUrl}`,
+      );
+    }
+
+    issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+    await this.issueRepository.update(issue, project);
+    await this.issueRepository.updateStatus(
+      project,
+      issue,
+      awaitingWorkspaceStatusOption.id,
+    );
+    await this.patchConsoleTab(issue);
+    await this.issueCommentRepository.createComment(
+      issue,
+      `Session ended: agent definition \`${missingAgentName}\` was not found.\nItem blocked until the following task issue is resolved:\n${taskIssueUrl}`,
+    );
+  };
+
   private isAuthorTrusted = (
     author: string,
     allowedIssueAuthors: string[] | null,

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

@@ -189,7 +189,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -359,7 +359,7 @@ describe('StartPreparationUseCase', () => {
       expect(mockIssueRepository.setIssueAgentField.mock.calls).toHaveLength(0);
       expect(mockIssueRepository.removeLabel.mock.calls).toHaveLength(0);
       expect(mockLocalCommandRunner.runCommand.mock.calls[0][1][1]).toBe(
-        'triager',
+        'agent1',
       );
     });
 
@@ -507,7 +507,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -566,7 +566,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'https://github.com/user/repo/pull/354',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -803,7 +803,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'https://github.com/user/repo/issues/1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1081,7 +1081,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1127,7 +1127,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1136,7 +1136,7 @@ describe('StartPreparationUseCase', () => {
       ],
     ]);
   });
-  it('should use llm-agent label over category label and defaultLlmAgentName', async () => {
+  it('falls back to defaultAgentName when Agent field is empty, ignoring llm-agent: labels', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -1173,7 +1173,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'research',
+        'agent1',
         'claude-sonnet-4-6',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1182,7 +1182,7 @@ describe('StartPreparationUseCase', () => {
       ],
     ]);
   });
-  it('should use category label over defaultLlmAgentName when no llm-agent label', async () => {
+  it('falls back to defaultAgentName when Agent field is empty, ignoring category: labels', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -1219,7 +1219,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-sonnet-4-6',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1228,7 +1228,7 @@ describe('StartPreparationUseCase', () => {
       ],
     ]);
   });
-  it('should use defaultLlmAgentName over defaultAgentName when no label', async () => {
+  it('falls back to defaultAgentName when Agent field is empty, ignoring defaultLlmAgentName', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -1265,7 +1265,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'default-llm-agent',
+        'agent1',
         'claude-sonnet-4-6',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1311,7 +1311,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-sonnet',
         '--configFilePath',
         '/path/to/config.yml',
@@ -1412,7 +1412,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url2',
-        'impl',
+        'agent1',
         'claude-sonnet-4-6',
         '--configFilePath',
         '/path/to/config.yml',
@@ -2594,7 +2594,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -2643,7 +2643,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -2692,7 +2692,7 @@ describe('StartPreparationUseCase', () => {
       'aw',
       [
         'url1',
-        'impl',
+        'agent1',
         'claude-opus',
         '--configFilePath',
         '/path/to/config.yml',
@@ -5201,54 +5201,54 @@ describe('StartPreparationUseCase', () => {
       expect(selectedAgent).toBe('developer');
     });
 
-    it('selects explicit llm-agent: label over labelsAsLlmAgentName mapping', async () => {
+    it('uses defaultAgentName when Agent field is empty, ignoring llm-agent: label and labelsAsLlmAgentName', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['llm-agent:explicit-agent', 'story', 'category:impl'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story'],
       });
-      expect(selectedAgent).toBe('explicit-agent');
+      expect(selectedAgent).toBe('default-agent');
     });
 
-    it('uses the label name as the agent name when an issue label is listed in labelsAsLlmAgentName, over category: label', async () => {
+    it('uses defaultAgentName when Agent field is empty, ignoring labelsAsLlmAgentName and category: label', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['story', 'category:impl'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story'],
       });
-      expect(selectedAgent).toBe('story');
+      expect(selectedAgent).toBe('default-agent');
     });
 
-    it('matches labelsAsLlmAgentName entries exactly including colons in the label name', async () => {
+    it('uses defaultAgentName when Agent field is empty, ignoring colon-containing label in labelsAsLlmAgentName', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['story:body-condition', 'category:impl'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story', 'story:body-condition'],
       });
-      expect(selectedAgent).toBe('story:body-condition');
+      expect(selectedAgent).toBe('default-agent');
     });
 
-    it('falls through to category: label when no llm-agent: label and no issue label is in labelsAsLlmAgentName', async () => {
+    it('uses defaultAgentName when Agent field is empty, ignoring category: label and unmatched labelsAsLlmAgentName', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['unrelated-label', 'category:impl'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story'],
       });
-      expect(selectedAgent).toBe('impl');
+      expect(selectedAgent).toBe('default-agent');
     });
 
-    it('falls through to defaultLlmAgentName when no llm-agent:, no labelsAsLlmAgentName match, and no category: label', async () => {
+    it('uses defaultAgentName when Agent field is empty, ignoring defaultLlmAgentName', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['unrelated-label'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story'],
       });
-      expect(selectedAgent).toBe('default-llm-agent');
+      expect(selectedAgent).toBe('default-agent');
     });
 
     it('falls through to defaultAgentName when no llm-agent:, no labelsAsLlmAgentName match, no category: label, and no defaultLlmAgentName', async () => {
@@ -5268,7 +5268,7 @@ describe('StartPreparationUseCase', () => {
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story'],
       });
-      expect(selectedAgent).toBe('default-llm-agent');
+      expect(selectedAgent).toBe('default-agent');
     });
 
     it('ignores labels that are not listed in labelsAsLlmAgentName when other entries are present', async () => {
@@ -5278,17 +5278,27 @@ describe('StartPreparationUseCase', () => {
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: ['story', 'story:body-condition'],
       });
-      expect(selectedAgent).toBe('default-llm-agent');
+      expect(selectedAgent).toBe('default-agent');
     });
 
-    it('does not affect selection when labelsAsLlmAgentName is null and only category: label is present', async () => {
+    it('uses defaultAgentName when labelsAsLlmAgentName is null and Agent field is empty', async () => {
       const selectedAgent = await runWithIssueLabels({
         labels: ['category:impl'],
         defaultAgentName: 'default-agent',
         defaultLlmAgentName: 'default-llm-agent',
         labelsAsLlmAgentName: null,
       });
-      expect(selectedAgent).toBe('impl');
+      expect(selectedAgent).toBe('default-agent');
+    });
+
+    it('uses defaultAgentName when Agent field is empty and a bare label matches labelsAsLlmAgentName', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['chore'],
+        defaultAgentName: 'triage-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['chore'],
+      });
+      expect(selectedAgent).toBe('triage-agent');
     });
   });
 
@@ -5347,7 +5357,7 @@ describe('StartPreparationUseCase', () => {
       expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
       expect(mockLocalCommandRunner.runCommand.mock.calls[0][1]).toEqual([
         'url1',
-        'impl',
+        'agent1',
         'claude-opus-4-8',
         '--configFilePath',
         '/path/to/config.yml',

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -9,9 +9,7 @@ import {
   AWAITING_WORKSPACE_STATUS_NAME,
   PREPARATION_STATUS_NAME,
 } from '../entities/WorkflowStatus';
-import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
+import { adoptIssueAgentDesignationLabel } from './AgentDesignationLabelAdoptUseCase';
 
 const NORMAL_CONCURRENT_LIMIT = 6;
 const SEVEN_DAY_THROTTLE_START_THRESHOLD = 0.8;
@@ -310,41 +308,6 @@ export class StartPreparationUseCase {
     return [...selectedEntries, ...excluded];
   };
 
-  private migrateAgentDesignationLabelToProjectField = async (
-    issue: Issue,
-    project: Project,
-    configuredAgentNames: string[] | null,
-  ): Promise<void> => {
-    const agentLabel =
-      configuredAgentNames === null
-        ? undefined
-        : issue.labels.find((label: string) =>
-            configuredAgentNames.includes(label),
-          );
-    if (agentLabel === undefined) {
-      return;
-    }
-    issue.agent = agentLabel;
-    const agentOptionId = await ensureAgentOptionAndGetId(
-      this.projectRepository,
-      project,
-      agentLabel,
-    );
-    if (agentOptionId === null) {
-      console.warn(
-        `Agent field option '${agentLabel}' could not be resolved for ${issue.url}. Keeping the label as the agent designation.`,
-      );
-      return;
-    }
-    await this.issueRepository.setIssueAgentField(
-      issue.url,
-      project,
-      agentOptionId,
-    );
-    await this.issueRepository.removeLabel(issue, agentLabel);
-    issue.labels = issue.labels.filter((label) => label !== agentLabel);
-  };
-
   run = async (params: {
     projectUrl: string;
     defaultAgentName: string;
@@ -520,31 +483,15 @@ export class StartPreparationUseCase {
         exclusionCounts.notAssignedToManager++;
         continue;
       }
-      await this.migrateAgentDesignationLabelToProjectField(
+      await adoptIssueAgentDesignationLabel(
         issue,
         project,
-        params.agents ?? null,
+        params.agents ?? [],
+        this.projectRepository,
+        this.issueRepository,
       );
-      const mappedAgentFromLabel =
-        params.labelsAsLlmAgentName !== null
-          ? issue.labels.find((label: string) =>
-              params.labelsAsLlmAgentName !== null
-                ? params.labelsAsLlmAgentName.includes(label)
-                : false,
-            )
-          : undefined;
       const agent =
         (issue.agent === null ? null : agentNameFromDesignation(issue.agent)) ||
-        issue.labels
-          .find((label: string) => label.startsWith(LLM_AGENT_LABEL_PREFIX))
-          ?.replace(LLM_AGENT_LABEL_PREFIX, '')
-          .trim() ||
-        mappedAgentFromLabel ||
-        issue.labels
-          .find((label: string) => label.startsWith('category:'))
-          ?.replace('category:', '')
-          .trim() ||
-        params.defaultLlmAgentName ||
         params.defaultAgentName;
       const labelModelName = issue.labels
         .find((label: string) => label.startsWith('llm-model:'))

package/types/adapter/entry-points/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AA8LzB,eAAO,MAAM,OAAO,SAAgB,CAAC;AA8gCrC,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,IAGxD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,EAAE,EACd,kBAAkB,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KACzC,OAAO,CAAC,IAAI,CAMd,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AAgMzB,eAAO,MAAM,OAAO,SAAgB,CAAC;AAwhCrC,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,IAGxD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,EAAE,EACd,kBAAkB,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KACzC,OAAO,CAAC,IAAI,CAMd,CAAC"}

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAiDA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAqD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA2xBP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAiDA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAsD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA8xBP;CACH"}

package/types/domain/usecases/AgentDesignationLabelAdoptUseCase.d.ts

@@ -0,0 +1,16 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+export declare const adoptIssueAgentDesignationLabel: (issue: Issue, project: Project, configuredAgentNames: string[], projectRepository: Pick<ProjectRepository, "getByUrl" | "createField" | "updateAgentList">, issueRepository: Pick<IssueRepository, "setIssueAgentField" | "removeLabel">) => Promise<void>;
+export declare class AgentDesignationLabelAdoptUseCase {
+    private readonly projectRepository;
+    private readonly issueRepository;
+    constructor(projectRepository: Pick<ProjectRepository, 'getByUrl' | 'createField' | 'updateAgentList'>, issueRepository: Pick<IssueRepository, 'setIssueAgentField' | 'removeLabel'>);
+    run: (params: {
+        project: Project;
+        issues: Issue[];
+        agents: string[] | null;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=AgentDesignationLabelAdoptUseCase.d.ts.map