github-issue-tower-defence-management 1.82.1 → 1.84.0

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

@@ -3776,74 +3776,6 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
   });
 
-  it('should exclude a token whose seven_day_sonnet weekly limit is rejected when the model is sonnet', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'url1',
-      title: 'Issue 1',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      number: 1,
-      itemId: 'item-1',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
-    const futureReset = Math.floor(Date.now() / 1000) + 3600;
-    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      {
-        name: 'token-sonnet-exhausted',
-        token: 'token-sonnet-exhausted',
-        fiveHourUtilization: 0.1,
-        sevenDayUtilization: 0,
-        blocked: false,
-        rejected: false,
-        blockedUntilEpoch: 0,
-        modelWeeklyLimits: {
-          seven_day_sonnet: { rejected: true, resetsAt: futureReset },
-        },
-      },
-      {
-        name: 'token-ok',
-        token: 'token-ok',
-        fiveHourUtilization: 0.5,
-        sevenDayUtilization: 0,
-        blocked: false,
-        rejected: false,
-        blockedUntilEpoch: 0,
-        modelWeeklyLimits: {},
-      },
-    ]);
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      fallbackLlmModelName: null,
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-      labelsAsLlmAgentName: null,
-    });
-
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
-  });
-
   it('should re-admit a token whose seven_day_sonnet rejection has been cleared by stale-reset expiry', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
@@ -5015,6 +4947,271 @@ describe('StartPreparationUseCase', () => {
     });
   });
 
+  describe('per-token model weekly-limit routing', () => {
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
+
+    it('routes a token whose seven_day_sonnet weekly limit is rejected to Opus while a sibling token with Sonnet headroom uses Sonnet in the same pass', async () => {
+      const issues = [
+        createMockIssue({
+          url: 'url1',
+          title: 'Issue 1',
+          labels: ['category:impl'],
+          status: 'Awaiting Workspace',
+          number: 1,
+          itemId: 'item-1',
+        }),
+        createMockIssue({
+          url: 'url2',
+          title: 'Issue 2',
+          labels: ['category:impl'],
+          status: 'Awaiting Workspace',
+          number: 2,
+          itemId: 'item-2',
+        }),
+      ];
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap(issues),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-sonnet-exhausted',
+          token: 'token-sonnet-exhausted',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0,
+          blocked: false,
+          rejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {
+            seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+          },
+        },
+        {
+          name: 'token-sonnet-ok',
+          token: 'token-sonnet-ok',
+          fiveHourUtilization: 0.5,
+          sevenDayUtilization: 0,
+          blocked: false,
+          rejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {},
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        fallbackLlmModelName: 'claude-opus-4-8',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
+        allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
+      const callForExhausted =
+        mockLocalCommandRunner.runCommand.mock.calls.find(
+          (call) =>
+            call[2]?.env?.CLAUDE_CODE_OAUTH_TOKEN === 'token-sonnet-exhausted',
+        );
+      const callForOk = mockLocalCommandRunner.runCommand.mock.calls.find(
+        (call) => call[2]?.env?.CLAUDE_CODE_OAUTH_TOKEN === 'token-sonnet-ok',
+      );
+      expect(callForExhausted).toBeDefined();
+      expect(callForOk).toBeDefined();
+      expect(callForExhausted?.[1][2]).toBe('claude-opus-4-8');
+      expect(callForOk?.[1][2]).toBe('claude-sonnet-4-6');
+    });
+
+    it('excludes a token whose seven_day_sonnet and seven_day_opus weekly limits are both rejected', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-both-exhausted',
+          token: 'token-both-exhausted',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0,
+          blocked: false,
+          rejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {
+            seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+            seven_day_opus: { rejected: true, resetsAt: futureReset },
+          },
+        },
+      ]);
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        fallbackLlmModelName: 'claude-opus-4-8',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
+        allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Skipping starting preparation'),
+      );
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('excludes a token whose generic seven_day weekly limit is rejected even when the per-model windows are open', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-general-exhausted',
+          token: 'token-general-exhausted',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0,
+          blocked: false,
+          rejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {
+            seven_day: { rejected: true, resetsAt: futureReset },
+          },
+        },
+      ]);
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        fallbackLlmModelName: 'claude-opus-4-8',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
+        allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Skipping starting preparation'),
+      );
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('lets a per-issue llm-model label override the per-token routed model', async () => {
+      const awaitingIssue = createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl', 'llm-model:claude-3-5-haiku-20241022'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([awaitingIssue]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+        {
+          name: 'token-sonnet-exhausted',
+          token: 'token-sonnet-exhausted',
+          fiveHourUtilization: 0.1,
+          sevenDayUtilization: 0,
+          blocked: false,
+          rejected: false,
+          blockedUntilEpoch: 0,
+          modelWeeklyLimits: {
+            seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+          },
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        fallbackLlmModelName: 'claude-opus-4-8',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
+        allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
+      });
+
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+      expect(mockLocalCommandRunner.runCommand.mock.calls[0][1][2]).toBe(
+        'claude-3-5-haiku-20241022',
+      );
+      expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+        env: {
+          CLAUDE_CODE_OAUTH_TOKEN: 'token-sonnet-exhausted',
+          ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+        },
+      });
+    });
+  });
+
   describe('per-token in-flight global concurrency enforcement', () => {
     it('should not spawn when the selected token already has its full in-flight limit occupied by processes from other projects', async () => {
       const awaitingIssues: Issue[] = [

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -61,6 +61,29 @@ export class StartPreparationUseCase {
     return general !== undefined && general.rejected;
   };
 
+  private selectModelForToken = (
+    usage: ClaudeTokenUsage,
+    defaultModelName: string | null,
+    fallbackModelName: string | null,
+  ): string | null => {
+    const generalWeeklyLimit = usage.modelWeeklyLimits['seven_day'];
+    if (generalWeeklyLimit !== undefined && generalWeeklyLimit.rejected) {
+      return null;
+    }
+    const candidateModelNames = [defaultModelName, fallbackModelName].filter(
+      (modelName): modelName is string =>
+        modelName !== null && modelName !== '',
+    );
+    for (const candidateModelName of candidateModelNames) {
+      const weeklyLimitType = this.weeklyLimitTypeForModel(candidateModelName);
+      const specificWeeklyLimit = usage.modelWeeklyLimits[weeklyLimitType];
+      if (specificWeeklyLimit === undefined || !specificWeeklyLimit.rejected) {
+        return candidateModelName;
+      }
+    }
+    return null;
+  };
+
   private secondsUntilSevenDayReset = (
     usage: ClaudeTokenUsage,
     weeklyLimitType: string,
@@ -79,18 +102,19 @@ export class StartPreparationUseCase {
 
   private compareBySevenDayDeadlineThenUtilization = (
     a: ClaudeTokenUsage,
+    aWeeklyLimitType: string,
     b: ClaudeTokenUsage,
-    weeklyLimitType: string,
+    bWeeklyLimitType: string,
     nowEpochSeconds: number,
   ): number => {
     const aSecondsUntilReset = this.secondsUntilSevenDayReset(
       a,
-      weeklyLimitType,
+      aWeeklyLimitType,
       nowEpochSeconds,
     );
     const bSecondsUntilReset = this.secondsUntilSevenDayReset(
       b,
-      weeklyLimitType,
+      bWeeklyLimitType,
       nowEpochSeconds,
     );
     if (aSecondsUntilReset !== bSecondsUntilReset) {
@@ -128,35 +152,43 @@ export class StartPreparationUseCase {
   private selectRotationTokens = (
     tokenUsages: ClaudeTokenUsage[],
     utilizationPercentageThreshold: number,
-    modelName: string | null,
+    defaultModelName: string | null,
+    fallbackModelName: string | null,
     maxConcurrent: number,
   ): {
     tokens: string[];
     effectiveCap: number;
     tokensWithLimits: Array<{
       token: string;
+      model: string;
       limit: number;
       secondsUntilSevenDayReset: number;
     }>;
   } => {
-    const weeklyLimitType = this.weeklyLimitTypeForModel(modelName);
     const nowEpochSeconds = Date.now() / 1000;
     const eligibleTokens = tokenUsages
       .filter((usage) => !usage.blocked)
       .filter((usage) => !usage.rejected)
       .filter((usage) => !this.isWithinCooldown(usage, nowEpochSeconds))
-      .filter(
-        (usage) => !this.isModelWeeklyLimitRejected(usage, weeklyLimitType),
-      )
       .filter(
         (usage) =>
           usage.fiveHourUtilization * 100 < utilizationPercentageThreshold,
       )
+      .flatMap((usage) => {
+        const model = this.selectModelForToken(
+          usage,
+          defaultModelName,
+          fallbackModelName,
+        );
+        if (model === null) return [];
+        return [{ usage, model }];
+      })
       .sort((a, b) =>
         this.compareBySevenDayDeadlineThenUtilization(
-          a,
-          b,
-          weeklyLimitType,
+          a.usage,
+          this.weeklyLimitTypeForModel(a.model),
+          b.usage,
+          this.weeklyLimitTypeForModel(b.model),
           nowEpochSeconds,
         ),
       );
@@ -165,15 +197,16 @@ export class StartPreparationUseCase {
       return { tokens: [], effectiveCap: 0, tokensWithLimits: [] };
     }
 
-    const tokensWithLimits = eligibleTokens.map((usage) => ({
+    const tokensWithLimits = eligibleTokens.map(({ usage, model }) => ({
       token: usage.token,
+      model,
       limit: this.getTokenConcurrentLimit(
         usage.fiveHourUtilization,
         usage.sevenDayUtilization,
       ),
       secondsUntilSevenDayReset: this.secondsUntilSevenDayReset(
         usage,
-        weeklyLimitType,
+        this.weeklyLimitTypeForModel(model),
         nowEpochSeconds,
       ),
     }));
@@ -215,6 +248,7 @@ export class StartPreparationUseCase {
       .sort((a, b) =>
         this.compareBySevenDayDeadlineThenUtilization(
           a,
+          weeklyLimitType,
           b,
           weeklyLimitType,
           nowEpochSeconds,
@@ -272,6 +306,7 @@ export class StartPreparationUseCase {
     let proxyBaseUrl: string | null = null;
     let selectedTokensWithLimits: Array<{
       token: string;
+      model: string;
       limit: number;
       secondsUntilSevenDayReset: number;
     }> = [];
@@ -287,51 +322,23 @@ export class StartPreparationUseCase {
     const maximumPreparingIssuesCount =
       params.maximumPreparingIssuesCount ?? NORMAL_CONCURRENT_LIMIT;
     let effectiveMaxPreparingIssuesCount = maximumPreparingIssuesCount;
-    let effectiveDefaultLlmModelName = params.defaultLlmModelName;
+    const fallbackLlmModelName =
+      params.fallbackLlmModelName ?? DEFAULT_FALLBACK_LLM_MODEL_NAME;
     if (tokenUsages.length > 0) {
       const {
-        tokens: ranked,
-        effectiveCap,
-        tokensWithLimits: rankedTokensWithLimits,
+        tokens: selectedTokens,
+        effectiveCap: selectedCap,
+        tokensWithLimits: selectedTokensWithLimitsLocal,
       } = this.selectRotationTokens(
         tokenUsages,
         params.utilizationPercentageThreshold,
         params.defaultLlmModelName,
+        fallbackLlmModelName,
         maximumPreparingIssuesCount,
       );
-      let selectedTokens = ranked;
-      let selectedCap = effectiveCap;
-      let selectedTokensWithLimitsLocal = rankedTokensWithLimits;
-      if (
-        selectedTokens.length === 0 &&
-        this.weeklyLimitTypeForModel(params.defaultLlmModelName) ===
-          'seven_day_sonnet'
-      ) {
-        const fallbackModelName =
-          params.fallbackLlmModelName ?? DEFAULT_FALLBACK_LLM_MODEL_NAME;
-        const {
-          tokens: fallbackRanked,
-          effectiveCap: fallbackCap,
-          tokensWithLimits: fallbackTokensWithLimits,
-        } = this.selectRotationTokens(
-          tokenUsages,
-          params.utilizationPercentageThreshold,
-          fallbackModelName,
-          maximumPreparingIssuesCount,
-        );
-        if (fallbackRanked.length > 0) {
-          console.warn(
-            `Sonnet 7-day weekly limit (${this.weeklyLimitTypeForModel(params.defaultLlmModelName)}) is exhausted across all configured Claude OAuth token(s). Falling back to ${fallbackModelName}.`,
-          );
-          selectedTokens = fallbackRanked;
-          selectedCap = fallbackCap;
-          selectedTokensWithLimitsLocal = fallbackTokensWithLimits;
-          effectiveDefaultLlmModelName = fallbackModelName;
-        }
-      }
       if (selectedTokens.length === 0) {
         console.warn(
-          `All ${tokenUsages.length} configured Claude OAuth token(s) are unavailable (blocked, rejected, weekly limit for ${this.weeklyLimitTypeForModel(params.defaultLlmModelName)} exhausted, or 5h utilization >= ${params.utilizationPercentageThreshold}%). Skipping starting preparation.`,
+          `All ${tokenUsages.length} configured Claude OAuth token(s) are unavailable (blocked, rejected, weekly limits for the configured model(s) exhausted, or 5h utilization >= ${params.utilizationPercentageThreshold}%). Skipping starting preparation.`,
         );
         return { rotationOrder };
       }
@@ -434,12 +441,15 @@ export class StartPreparationUseCase {
           .trim() ||
         params.defaultLlmAgentName ||
         params.defaultAgentName;
-      const model =
-        issue.labels
-          .find((label: string) => label.startsWith('llm-model:'))
-          ?.replace('llm-model:', '')
-          .trim() || effectiveDefaultLlmModelName;
-      if (!model) {
+      const labelModelName = issue.labels
+        .find((label: string) => label.startsWith('llm-model:'))
+        ?.replace('llm-model:', '')
+        .trim();
+      if (
+        !labelModelName &&
+        !params.defaultLlmModelName &&
+        rotationTokens === null
+      ) {
         console.error(
           `No LLM model configured for issue ${issue.url}. Provide --defaultLlmModelName or add an llm-model: label.`,
         );
@@ -522,30 +532,13 @@ export class StartPreparationUseCase {
       );
       issue.status = PREPARATION_STATUS_NAME;
 
-      const awArgs: string[] = [
-        issue.url,
-        agent,
-        model,
-        '--configFilePath',
-        params.configFilePath,
-        '--branch',
-        branchName,
-      ];
-      if (
-        params.codexHomeCandidates !== null &&
-        params.codexHomeCandidates.length > 0
-      ) {
-        const codexHome =
-          params.codexHomeCandidates[
-            startedInThisRunCount % params.codexHomeCandidates.length
-          ];
-        awArgs.push('--codexHome', codexHome);
-      }
       let spawnEnv: Record<string, string> | undefined;
+      let routedModelName: string | null = null;
       if (rotationTokens !== null && proxyBaseUrl !== null) {
         const tokenWithSoonestResetAmongAvailable = selectedTokensWithLimits
           .map((t) => ({
             token: t.token,
+            model: t.model,
             remaining:
               t.limit -
               (tokenInFlightCounts[t.token] ?? 0) -
@@ -563,6 +556,7 @@ export class StartPreparationUseCase {
           break;
         }
         const selected = tokenWithSoonestResetAmongAvailable.token;
+        routedModelName = tokenWithSoonestResetAmongAvailable.model;
         spawnedInThisRunByToken[selected] =
           (spawnedInThisRunByToken[selected] ?? 0) + 1;
         spawnEnv = {
@@ -570,6 +564,33 @@ export class StartPreparationUseCase {
           ANTHROPIC_BASE_URL: proxyBaseUrl,
         };
       }
+      const model =
+        labelModelName || routedModelName || params.defaultLlmModelName;
+      if (!model) {
+        console.error(
+          `No LLM model configured for issue ${issue.url}. Provide --defaultLlmModelName or add an llm-model: label.`,
+        );
+        continue;
+      }
+      const awArgs: string[] = [
+        issue.url,
+        agent,
+        model,
+        '--configFilePath',
+        params.configFilePath,
+        '--branch',
+        branchName,
+      ];
+      if (
+        params.codexHomeCandidates !== null &&
+        params.codexHomeCandidates.length > 0
+      ) {
+        const codexHome =
+          params.codexHomeCandidates[
+            startedInThisRunCount % params.codexHomeCandidates.length
+          ];
+        awArgs.push('--codexHome', codexHome);
+      }
       await this.localCommandRunner.runCommand(
         'aw',
         awArgs,