github-issue-tower-defence-management 1.164.0 → 1.165.1

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

@@ -3,6 +3,7 @@ import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
 import { Comment } from '../entities/Comment';
 import { StoryObjectMap } from '../entities/StoryObjectMap';
+import { AGENT_FIELD_NAME } from '../entities/RequiredProjectField';
 
 const createMockProject = (overrides: Partial<Project> = {}): Project => ({
   id: 'project-1',
@@ -45,6 +46,7 @@ const createMockProject = (overrides: Partial<Project> = {}): Project => ({
   remainingEstimationMinutes: null,
   dependedIssueUrlSeparatedByComma: null,
   completionDate50PercentConfidence: null,
+  agent: null,
   ...overrides,
 });
 
@@ -73,6 +75,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   createdAt: new Date(),
   author: '',
   closingIssueReferenceUrls: [],
+  agent: null,
   ...overrides,
 });
 
@@ -87,6 +90,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
   let useCase: NotifyFinishedIssuePreparationUseCase;
   let mockProjectRepository: {
     getByUrl: jest.Mock;
+    updateAgentList: jest.Mock;
+    createField: jest.Mock;
   };
   let mockIssueRepository: {
     get: jest.Mock;
@@ -101,6 +106,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     approvePullRequest: jest.Mock;
     requestChangesWithInlineComment: jest.Mock;
     setDependedIssueUrl: jest.Mock;
+    setIssueAgentField: jest.Mock;
   };
   let mockIssueCommentRepository: {
     getCommentsFromIssue: jest.Mock;
@@ -123,6 +129,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
 
     mockProjectRepository = {
       getByUrl: jest.fn(),
+      updateAgentList: jest.fn().mockResolvedValue([]),
+      createField: jest.fn().mockResolvedValue(undefined),
     };
 
     mockIssueRepository = {
@@ -138,6 +146,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       approvePullRequest: jest.fn().mockResolvedValue(undefined),
       requestChangesWithInlineComment: jest.fn().mockResolvedValue(undefined),
       setDependedIssueUrl: jest.fn(),
+      setIssueAgentField: jest.fn().mockResolvedValue(undefined),
     };
 
     mockIssueCommentRepository = {
@@ -3599,6 +3608,153 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     });
   });
 
+  describe('nextStepAgent handling', () => {
+    const makeProjectWithAgent = () =>
+      createMockProject({
+        agent: {
+          name: 'Agent',
+          fieldId: 'agent-field-id',
+          options: [
+            { id: 'opt-impl', name: 'impl', color: 'GRAY', description: '' },
+          ],
+        },
+      });
+
+    it('calls setIssueAgentField with existing option ID when nextStepAgent is in last comment', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "do something", "nextStepAgent": "impl"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithAgent,
+        'opt-impl',
+      );
+    });
+
+    it('creates a new agent option and calls setIssueAgentField when nextStepAgent is not an existing option', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "review", "nextStepAgent": "chore"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+      mockProjectRepository.updateAgentList.mockResolvedValue([
+        { id: 'opt-impl', name: 'impl', color: 'GRAY', description: '' },
+        { id: 'opt-chore-new', name: 'chore', color: 'GRAY', description: '' },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockProjectRepository.updateAgentList).toHaveBeenCalledWith(
+        projectWithAgent,
+        expect.arrayContaining([
+          expect.objectContaining({ name: 'impl' }),
+          expect.objectContaining({ id: null, name: 'chore', color: 'GRAY' }),
+        ]),
+      );
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithAgent,
+        'opt-chore-new',
+      );
+    });
+
+    it('does not call setIssueAgentField when nextStepAgent is absent from the last comment', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": null}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+      expect(mockProjectRepository.updateAgentList).not.toHaveBeenCalled();
+    });
+
+    it('creates agent field via createField and does not call setIssueAgentField when project has no agent field and re-fetch also returns no agent', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithoutAgent = createMockProject({ agent: null });
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "go", "nextStepAgent": "impl"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockProjectRepository.createField).toHaveBeenCalledWith(
+        projectWithoutAgent,
+        {
+          name: AGENT_FIELD_NAME,
+          dataType: 'SINGLE_SELECT',
+          options: [{ name: 'impl', color: 'GRAY', description: '' }],
+        },
+      );
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+    });
+  });
+
   describe('consoleTabsRepository integration', () => {
     let mockConsoleTabsRepository: {
       patchIssueTabTransition: jest.Mock;

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -25,6 +25,9 @@ import {
   ConsoleTabName,
 } from './console/GenerateConsoleListsUseCase';
 import { Issue } from '../entities/Issue';
+import { FieldOption, Project } from '../entities/Project';
+import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
+import { AGENT_FIELD_NAME } from '../entities/RequiredProjectField';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -52,7 +55,10 @@ export class NotifyFinishedIssuePreparationUseCase {
   private readonly changeTargetPullRequestApprover: ChangeTargetPullRequestApprover;
 
   constructor(
-    private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
+    private readonly projectRepository: Pick<
+      ProjectRepository,
+      'getByUrl' | 'updateAgentList' | 'createField'
+    >,
     private readonly issueRepository: Pick<
       IssueRepository,
       | 'get'
@@ -67,6 +73,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'approvePullRequest'
       | 'requestChangesWithInlineComment'
       | 'setDependedIssueUrl'
+      | 'setIssueAgentField'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -93,6 +100,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     labelsAsLlmAgentName?: string[] | null;
     labelsNotRequiringPullRequest?: string[] | null;
     changeTargetPathAliases?: Record<string, string> | null;
+    agents?: string[] | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -195,41 +203,53 @@ export class NotifyFinishedIssuePreparationUseCase {
     const isTrustedAuthor = (author: string): boolean =>
       this.isAuthorTrusted(author, params.allowedIssueAuthors ?? null);
 
-    const lastComment = comments[comments.length - 1];
-    if (
-      lastComment &&
-      isTrustedAuthor(lastComment.author) &&
-      lastComment.content.startsWith('From: :robot:')
-    ) {
-      const nextStepAgent = this.extractNextStepAgent(lastComment.content);
-      if (nextStepAgent !== null) {
-        await this.issueRepository.getOrCreateLabel(
-          issue.org,
-          issue.repo,
-          nextStepAgent,
-        );
-        const agentLabels = params.labelsAsLlmAgentName ?? [];
-        const filteredLabels = issue.labels.filter(
-          (label) =>
-            !label.startsWith('llm-agent:') && !agentLabels.includes(label),
-        );
-        const updatedLabels = [...new Set([...filteredLabels, nextStepAgent])];
-        issue.labels = updatedLabels;
-        issue.status = AWAITING_WORKSPACE_STATUS_NAME;
-        await this.issueRepository.update(issue, project);
-        await this.issueRepository.updateStatus(
+    const lastTrustedBotComment = [...comments]
+      .reverse()
+      .find(
+        (c) =>
+          isTrustedAuthor(c.author) && c.content.startsWith('From: :robot:'),
+      );
+    const nextStepAgent = lastTrustedBotComment
+      ? this.extractNextStepAgent(lastTrustedBotComment.content)
+      : null;
+    if (nextStepAgent !== null) {
+      const agentOptionId = await this.ensureAgentOptionAndGetId(
+        project,
+        nextStepAgent,
+      );
+      if (agentOptionId) {
+        await this.issueRepository.setIssueAgentField(
+          params.issueUrl,
           project,
-          issue,
-          awaitingWorkspaceStatusOption.id,
+          agentOptionId,
         );
-        await this.issueRepository.updateLabels(issue, updatedLabels);
-        await this.patchConsoleTab(issue);
-        await this.issueCommentRepository.createComment(
-          issue,
-          `Next step agent: ${nextStepAgent}`,
-        );
-        return;
       }
+      await this.issueRepository.getOrCreateLabel(
+        issue.org,
+        issue.repo,
+        nextStepAgent,
+      );
+      const agentLabels = params.labelsAsLlmAgentName ?? [];
+      const filteredLabels = issue.labels.filter(
+        (label) =>
+          !label.startsWith('llm-agent:') && !agentLabels.includes(label),
+      );
+      const updatedLabels = [...new Set([...filteredLabels, nextStepAgent])];
+      issue.labels = updatedLabels;
+      issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+      await this.issueRepository.update(issue, project);
+      await this.issueRepository.updateStatus(
+        project,
+        issue,
+        awaitingWorkspaceStatusOption.id,
+      );
+      await this.issueRepository.updateLabels(issue, updatedLabels);
+      await this.patchConsoleTab(issue);
+      await this.issueCommentRepository.createComment(
+        issue,
+        `Next step agent: ${nextStepAgent}`,
+      );
+      return;
     }
 
     const { rejections, approvedPrUrl } = await this.collectRejections(
@@ -444,37 +464,6 @@ export class NotifyFinishedIssuePreparationUseCase {
     return nextStepValue !== null && nextStepValue !== undefined;
   };
 
-  private extractNextStepAgent = (body: string): string | null => {
-    const reportMatch = body.match(/```json\n([\s\S]*?)\n```/);
-    if (!reportMatch || reportMatch.length < 2) {
-      return null;
-    }
-    let reportJson: unknown;
-    try {
-      reportJson = JSON.parse(reportMatch[1]);
-    } catch (error) {
-      console.warn(
-        'Invalid JSON in report body while checking nextStepAgent:',
-        error,
-      );
-      return null;
-    }
-    if (typeof reportJson !== 'object' || reportJson === null) {
-      return null;
-    }
-    if (!('nextStepAgent' in reportJson)) {
-      return null;
-    }
-    const nextStepAgentValue = Reflect.get(reportJson, 'nextStepAgent');
-    if (
-      typeof nextStepAgentValue !== 'string' ||
-      nextStepAgentValue.trim() === ''
-    ) {
-      return null;
-    }
-    return nextStepAgentValue;
-  };
-
   private setDependedIssueUrlForAllOpenPRs = async (
     issue: { url: string; labels: string[]; isPr: boolean },
     issueUrl: string,
@@ -550,6 +539,73 @@ export class NotifyFinishedIssuePreparationUseCase {
     return null;
   };
 
+  private extractNextStepAgent = (body: string): string | null => {
+    const reportMatch = body.match(/```json\n([\s\S]*?)\n```/);
+    if (!reportMatch || reportMatch.length < 2) {
+      return null;
+    }
+    let reportJson: unknown;
+    try {
+      reportJson = JSON.parse(reportMatch[1]);
+    } catch (error) {
+      console.warn(
+        'Invalid JSON in report body while checking nextStepAgent:',
+        error,
+      );
+      return null;
+    }
+    if (typeof reportJson !== 'object' || reportJson === null) {
+      return null;
+    }
+    if (!('nextStepAgent' in reportJson)) {
+      return null;
+    }
+    const value = Reflect.get(reportJson, 'nextStepAgent');
+    if (typeof value !== 'string' || value.trim() === '') {
+      return null;
+    }
+    return value.trim();
+  };
+
+  private ensureAgentOptionAndGetId = async (
+    project: Project,
+    agentName: string,
+  ): Promise<string | null> => {
+    const normalizedTarget = normalizeProjectFieldName(agentName);
+    if (!project.agent) {
+      await this.projectRepository.createField(project, {
+        name: AGENT_FIELD_NAME,
+        dataType: 'SINGLE_SELECT',
+        options: [{ name: agentName, color: 'GRAY' as const, description: '' }],
+      });
+      const refreshed = await this.projectRepository.getByUrl(project.url);
+      const created = refreshed.agent?.options.find(
+        (o) => normalizeProjectFieldName(o.name) === normalizedTarget,
+      );
+      return created?.id ?? null;
+    }
+    const existing = project.agent.options.find(
+      (o) => normalizeProjectFieldName(o.name) === normalizedTarget,
+    );
+    if (existing) {
+      return existing.id;
+    }
+    const mergedOptions: (Omit<FieldOption, 'id'> & {
+      id: FieldOption['id'] | null;
+    })[] = [
+      ...project.agent.options.map((o) => ({ ...o })),
+      { id: null, name: agentName, color: 'GRAY' as const, description: '' },
+    ];
+    const updatedOptions = await this.projectRepository.updateAgentList(
+      project,
+      mergedOptions,
+    );
+    const added = updatedOptions.find(
+      (o) => normalizeProjectFieldName(o.name) === normalizedTarget,
+    );
+    return added?.id ?? null;
+  };
+
   private patchConsoleTab = async (issue: Issue): Promise<void> => {
     if (!this.consoleTabsRepository) return;
     const targetTabName = this.resolveConsoleTargetTab(issue.status ?? '');

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

@@ -237,6 +237,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     createdAt: now,
     author: 'HiromiShikata',
     closingIssueReferenceUrls: [],
+    agent: null,
     ...overrides,
   });
 

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

@@ -1,6 +1,7 @@
 import { mock } from 'jest-mock-extended';
 import { FieldOption, Project } from '../entities/Project';
 import {
+  AGENT_FIELD_NAME,
   DEPENDED_ISSUE_URL_FIELD_NAME,
   NEXT_ACTION_DATE_FIELD_NAME,
   NEXT_ACTION_HOUR_FIELD_NAME,
@@ -27,6 +28,7 @@ describe('ProjectRequiredFieldCreateUseCase', () => {
     remainingEstimationMinutes: null,
     dependedIssueUrlSeparatedByComma: null,
     completionDate50PercentConfidence: null,
+    agent: null,
   };
 
   const buildProjectWithStory = (stories: FieldOption[]): Project => ({
@@ -50,13 +52,18 @@ describe('ProjectRequiredFieldCreateUseCase', () => {
       mock<
         Pick<
           ProjectRepository,
-          'getByUrl' | 'listFieldNames' | 'createField' | 'updateStoryList'
+          | 'getByUrl'
+          | 'listFieldNames'
+          | 'createField'
+          | 'updateStoryList'
+          | 'updateAgentList'
         >
       >();
     projectRepository.getByUrl.mockResolvedValue(project);
     projectRepository.listFieldNames.mockResolvedValue(existingFieldNames);
     projectRepository.createField.mockResolvedValue(undefined);
     projectRepository.updateStoryList.mockResolvedValue([]);
+    projectRepository.updateAgentList.mockResolvedValue([]);
     return {
       projectRepository,
       useCase: new ProjectRequiredFieldCreateUseCase(projectRepository),
@@ -592,4 +599,82 @@ describe('ProjectRequiredFieldCreateUseCase', () => {
       );
     });
   });
+
+  describe('reconcileAgentOptions', () => {
+    const buildProjectWithAgent = (
+      existingOptions: { id: string; name: string }[],
+    ): Project => ({
+      ...projectWithoutStory,
+      agent: {
+        name: 'Agent',
+        fieldId: 'agent-field-id',
+        options: existingOptions.map((o) => ({
+          ...o,
+          color: 'GRAY' as const,
+          description: '',
+        })),
+      },
+    });
+
+    it('adds missing agent names as GRAY options and calls updateAgentList', async () => {
+      const project = buildProjectWithAgent([{ id: 'opt-impl', name: 'impl' }]);
+      const { projectRepository, useCase } = createUseCase([], project);
+
+      await useCase.reconcileAgentOptions(project, ['impl', 'chore']);
+
+      expect(projectRepository.updateAgentList).toHaveBeenCalledWith(
+        project,
+        expect.arrayContaining([
+          expect.objectContaining({ id: 'opt-impl', name: 'impl' }),
+          expect.objectContaining({ id: null, name: 'chore', color: 'GRAY' }),
+        ]),
+      );
+    });
+
+    it('does not call updateAgentList when all agents already exist', async () => {
+      const project = buildProjectWithAgent([
+        { id: 'opt-impl', name: 'impl' },
+        { id: 'opt-chore', name: 'chore' },
+      ]);
+      const { projectRepository, useCase } = createUseCase([], project);
+
+      await useCase.reconcileAgentOptions(project, ['impl', 'chore']);
+
+      expect(projectRepository.updateAgentList).not.toHaveBeenCalled();
+    });
+
+    it('does not call updateAgentList when agentNames is null', async () => {
+      const project = buildProjectWithAgent([]);
+      const { projectRepository, useCase } = createUseCase([], project);
+
+      await useCase.reconcileAgentOptions(project, null);
+
+      expect(projectRepository.updateAgentList).not.toHaveBeenCalled();
+    });
+
+    it('calls createField with AGENT_FIELD_NAME and initial agents when project has no agent field', async () => {
+      const { projectRepository, useCase } = createUseCase(
+        [],
+        projectWithoutStory,
+      );
+
+      await useCase.reconcileAgentOptions(projectWithoutStory, [
+        'impl',
+        'chore',
+      ]);
+
+      expect(projectRepository.updateAgentList).not.toHaveBeenCalled();
+      expect(projectRepository.createField).toHaveBeenCalledWith(
+        projectWithoutStory,
+        {
+          name: AGENT_FIELD_NAME,
+          dataType: 'SINGLE_SELECT',
+          options: [
+            { name: 'impl', color: 'GRAY', description: '' },
+            { name: 'chore', color: 'GRAY', description: '' },
+          ],
+        },
+      );
+    });
+  });
 });

package/src/domain/usecases/ProjectRequiredFieldCreateUseCase.ts

@@ -1,12 +1,13 @@
 import { FieldOption, Project } from '../entities/Project';
 import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
 import {
+  AGENT_FIELD_NAME,
   REQUIRED_PROJECT_FIELDS,
   STORY_FIELD_NAME,
 } from '../entities/RequiredProjectField';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 
-type StoryOptionToSubmit = Omit<FieldOption, 'id'> & {
+type OptionToSubmit = Omit<FieldOption, 'id'> & {
   id: FieldOption['id'] | null;
 };
 
@@ -14,14 +15,25 @@ export class ProjectRequiredFieldCreateUseCase {
   constructor(
     private readonly projectRepository: Pick<
       ProjectRepository,
-      'getByUrl' | 'listFieldNames' | 'createField' | 'updateStoryList'
+      | 'getByUrl'
+      | 'listFieldNames'
+      | 'createField'
+      | 'updateStoryList'
+      | 'updateAgentList'
     >,
   ) {}
 
-  run = async (params: { projectUrl: string }): Promise<void> => {
+  run = async (params: {
+    projectUrl: string;
+    agents?: string[] | null;
+  }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
     await this.createMissingFields(project);
-    await this.reconcileStoryOptions(project);
+    const updatedProject = await this.projectRepository.getByUrl(
+      params.projectUrl,
+    );
+    await this.reconcileStoryOptions(updatedProject);
+    await this.reconcileAgentOptions(updatedProject, params.agents ?? null);
   };
 
   private createMissingFields = async (project: Project): Promise<void> => {
@@ -51,9 +63,9 @@ export class ProjectRequiredFieldCreateUseCase {
       return;
     }
     const requiredOptions = storyFieldDefinition.options;
-    const mergedOptions: StoryOptionToSubmit[] = project.story.stories.map(
-      (o) => ({ ...o }),
-    );
+    const mergedOptions: OptionToSubmit[] = project.story.stories.map((o) => ({
+      ...o,
+    }));
     let addedCount = 0;
     let previousRequiredIndex = -1;
     for (const required of requiredOptions) {
@@ -75,6 +87,47 @@ export class ProjectRequiredFieldCreateUseCase {
     await this.projectRepository.updateStoryList(project, mergedOptions);
   };
 
+  reconcileAgentOptions = async (
+    project: Project,
+    agentNames: string[] | null,
+  ): Promise<void> => {
+    if (!agentNames || agentNames.length === 0) {
+      return;
+    }
+    if (!project.agent) {
+      await this.projectRepository.createField(project, {
+        name: AGENT_FIELD_NAME,
+        dataType: 'SINGLE_SELECT',
+        options: agentNames.map((name) => ({
+          name,
+          color: 'GRAY' as const,
+          description: '',
+        })),
+      });
+      return;
+    }
+    const existingOptions = project.agent.options;
+    const existingNames = new Set(
+      existingOptions.map((o) => normalizeProjectFieldName(o.name)),
+    );
+    const toAdd = agentNames.filter(
+      (name) => !existingNames.has(normalizeProjectFieldName(name)),
+    );
+    if (toAdd.length === 0) {
+      return;
+    }
+    const mergedOptions: OptionToSubmit[] = [
+      ...existingOptions.map((o) => ({ ...o })),
+      ...toAdd.map((name) => ({
+        id: null,
+        name,
+        color: 'GRAY' as const,
+        description: '',
+      })),
+    ];
+    await this.projectRepository.updateAgentList(project, mergedOptions);
+  };
+
   private optionNameSatisfies = (
     currentName: string,
     requiredName: string,
@@ -82,4 +135,6 @@ export class ProjectRequiredFieldCreateUseCase {
     normalizeProjectFieldName(currentName).startsWith(
       normalizeProjectFieldName(requiredName),
     );
+
+  static readonly AGENT_FIELD_NAME = AGENT_FIELD_NAME;
 }