agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/src/providers/providers.ts

@@ -1,5 +1,7 @@
 import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
 import { ERROR_CODES } from '../core/error-codes.js';
+import { REGISTERED_PROVIDER_NAMES } from '../application/adapters/adapter-registry.js';
 
 export interface AppError extends Error {
   code?: string;
@@ -7,7 +9,7 @@ export interface AppError extends Error {
 }
 
 export interface ProviderSelection {
-  provider: 'codex' | 'claude' | 'gemini' | 'custom' | 'kiro-cli' | 'copilot';
+  provider: string;
   model: string;
   provider_config_env: string | null;
   provider_config_ref: string | null;
@@ -85,15 +87,8 @@ function resolveConfiguredAgentConfig(
   return null;
 }
 
-export const SUPPORTED_PROVIDERS = new Set<ProviderSelection['provider']>([
-  'codex',
-  'claude',
-  'gemini',
-  'custom',
-  'kiro-cli',
-  'copilot'
-]);
-export const AUTH_REQUIRED_PROVIDERS = new Set<ProviderSelection['provider']>(['codex', 'claude', 'gemini']);
+export const SUPPORTED_PROVIDERS: Set<string> = new Set(REGISTERED_PROVIDER_NAMES);
+export const AUTH_REQUIRED_PROVIDERS: Set<string> = new Set(['codex', 'claude', 'gemini']);
 export type ProviderSelectionResolver = (input: ResolveSelectionInput) => ProviderSelection;
 
 export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env, agentsConfig }) => {
@@ -121,7 +116,7 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
     throw error;
   }
 
-  if (!SUPPORTED_PROVIDERS.has(provider as ProviderSelection['provider'])) {
+  if (!SUPPORTED_PROVIDERS.has(provider)) {
     const error = new Error(ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER) as AppError;
     error.code = ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER;
     error.details = { provider };
@@ -129,7 +124,7 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
   }
 
   if (
-    AUTH_REQUIRED_PROVIDERS.has(provider as ProviderSelection['provider']) &&
+    AUTH_REQUIRED_PROVIDERS.has(provider) &&
     (!providerConfigEnv || !env[providerConfigEnv])
   ) {
     const error = new Error(ERROR_CODES.PROVIDER_AUTH_MISSING) as AppError;
@@ -151,7 +146,7 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
           : resolveConfiguredAgentConfig(provider, agentsConfig?.runtime);
 
   return {
-    provider: provider as ProviderSelection['provider'],
+    provider,
     model: model ?? `${provider}-default`,
     provider_config_env: providerConfigEnv,
     provider_config_ref: providerConfigEnv ? env[providerConfigEnv] ?? null : null,
@@ -183,13 +178,205 @@ export interface WorkerProvider {
       provider_config_ref: string | null;
     };
   }): Promise<Record<string, unknown>>;
+  sendMessage?(sessionId: string, message: string): Promise<void>;
+  attachToSession?(sessionId: string): Promise<void>;
+  getSessionInfo?(sessionId: string): Promise<{ active: boolean; provider: string }>;
+}
+
+export interface ProviderCommandResult {
+  exitCode: number;
+  signal: NodeJS.Signals | null;
+  errorCode?: number | string;
+}
+
+export interface ProviderCommandRunnerOptions {
+  interactive?: boolean;
+  stdin?: string;
+  env?: NodeJS.ProcessEnv;
+  timeoutMs?: number;
+}
+
+export interface ProviderCommandRunner {
+  run(command: string, args: string[], options?: ProviderCommandRunnerOptions): Promise<ProviderCommandResult>;
+}
+
+export class NodeProviderCommandRunner implements ProviderCommandRunner {
+  async run(command: string, args: string[], options: ProviderCommandRunnerOptions = {}): Promise<ProviderCommandResult> {
+    return await new Promise<ProviderCommandResult>((resolve) => {
+      let child;
+      try {
+        child = spawn(command, args, {
+          env: options.env,
+          stdio: options.interactive ? 'inherit' : ['pipe', 'pipe', 'pipe']
+        });
+      } catch {
+        resolve({
+          exitCode: 127,
+          signal: null,
+          errorCode: 'ENOENT'
+        });
+        return;
+      }
+
+      let spawnErrorCode: number | string | undefined;
+      child.on('error', (error: NodeJS.ErrnoException) => {
+        spawnErrorCode = error.code;
+      });
+
+      if (!options.interactive && typeof options.stdin === 'string' && child.stdin) {
+        child.stdin.write(options.stdin);
+      }
+      if (!options.interactive && child.stdin) {
+        child.stdin.end();
+      }
+
+      let timeoutHandle: NodeJS.Timeout | null = null;
+      if (!options.interactive && typeof options.timeoutMs === 'number' && options.timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+          child.kill('SIGKILL');
+        }, options.timeoutMs);
+      }
+
+      child.on('close', (code, signal) => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        resolve({
+          exitCode: code ?? (spawnErrorCode === 'ENOENT' ? 127 : 1),
+          signal,
+          errorCode: spawnErrorCode
+        });
+      });
+    });
+  }
+}
+
+interface ProviderCommandTemplate {
+  command: string;
+  args: string[];
+}
+
+interface ProviderCliCommands {
+  attach?: ProviderCommandTemplate;
+  send?: ProviderCommandTemplate;
+}
+
+interface NullWorkerProviderOptions {
+  commandRunner?: ProviderCommandRunner;
+}
+
+function readStringArray(value: unknown): string[] | null {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const strings = value.filter((item): item is string => typeof item === 'string');
+  return strings.length === value.length ? strings : null;
+}
+
+function resolveTemplateFromAgentConfig(
+  agentConfig: Record<string, unknown> | null | undefined,
+  kind: 'attach' | 'send',
+  fallback: ProviderCommandTemplate | undefined
+): ProviderCommandTemplate | undefined {
+  const nested = agentConfig?.[kind];
+  const nestedRecord = isPlainObject(nested) ? nested : null;
+
+  const explicitCommandKey = `${kind}_command`;
+  const explicitArgsKey = `${kind}_args`;
+  const explicitCommandValue = agentConfig?.[explicitCommandKey];
+  const command =
+    (nestedRecord && typeof nestedRecord.command === 'string' && nestedRecord.command.length > 0
+      ? nestedRecord.command
+      : null) ??
+    (typeof explicitCommandValue === 'string' && explicitCommandValue.length > 0
+      ? explicitCommandValue
+      : null) ??
+    fallback?.command;
+
+  const nestedArgs = nestedRecord ? readStringArray(nestedRecord.args) : null;
+  const explicitArgs = readStringArray(agentConfig?.[explicitArgsKey]);
+  const args = nestedArgs ?? explicitArgs ?? fallback?.args;
+
+  if (!command || !args) {
+    return undefined;
+  }
+  return { command, args };
+}
+
+function resolveProviderCommands(selection: ProviderSelection): ProviderCliCommands {
+  const defaults: Record<string, ProviderCliCommands> = {
+    codex: {
+      attach: { command: 'codex', args: ['chat', '--session', '{session_id}'] },
+      send: { command: 'codex', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
+    },
+    claude: {
+      attach: { command: 'claude-code', args: ['chat', '--session', '{session_id}'] },
+      send: { command: 'claude-code', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
+    }
+  };
+
+  const defaultsForProvider = defaults[selection.provider] ?? {};
+  return {
+    attach: resolveTemplateFromAgentConfig(selection.agent_config, 'attach', defaultsForProvider.attach),
+    send: resolveTemplateFromAgentConfig(selection.agent_config, 'send', defaultsForProvider.send)
+  };
+}
+
+function applyCommandArgsTemplate(
+  args: string[],
+  values: { sessionId: string; message?: string }
+): string[] {
+  return args.map((arg) => {
+    if (arg === '{session_id}') {
+      return values.sessionId;
+    }
+    if (arg === '{message}') {
+      return values.message ?? '';
+    }
+    return arg;
+  });
+}
+
+function commandFailureError(
+  provider: string,
+  capability: 'attach' | 'send',
+  details: Record<string, unknown>,
+  code: string
+): AppError {
+  const error = new Error(`${provider} provider ${capability} failed`) as AppError;
+  error.code = code;
+  error.details = details;
+  return error;
 }
 
 export class NullWorkerProvider implements WorkerProvider {
   selection: ProviderSelection;
+  sendMessage?: (sessionId: string, message: string) => Promise<void>;
+  attachToSession?: (sessionId: string) => Promise<void>;
+  getSessionInfo?: (sessionId: string) => Promise<{ active: boolean; provider: string }>;
+  private readonly commandRunner: ProviderCommandRunner;
+  private readonly commands: ProviderCliCommands;
 
-  constructor(selection: ProviderSelection) {
+  constructor(selection: ProviderSelection, options: NullWorkerProviderOptions = {}) {
     this.selection = selection;
+    this.commandRunner = options.commandRunner ?? new NodeProviderCommandRunner();
+    this.commands = resolveProviderCommands(selection);
+
+    if (this.commands.send) {
+      this.sendMessage = async (sessionId: string, message: string) => {
+        await this.executeCommand('send', sessionId, message);
+      };
+    }
+    if (this.commands.attach) {
+      this.attachToSession = async (sessionId: string) => {
+        await this.executeCommand('attach', sessionId);
+      };
+      this.getSessionInfo = (sessionId: string) =>
+        Promise.resolve({
+          active: Boolean(sessionId) && sessionId !== 'unknown' && sessionId !== 'unassigned',
+          provider: this.selection.provider
+        });
+    }
   }
 
   createSession(role: string, featureId: string, systemPrompt: string | null): Promise<WorkerSession> {
@@ -255,4 +442,38 @@ export class NullWorkerProvider implements WorkerProvider {
       content: `${role} session active for ${feature_id}.`
     });
   }
+
+  private async executeCommand(kind: 'attach' | 'send', sessionId: string, message?: string): Promise<void> {
+    const template = kind === 'attach' ? this.commands.attach : this.commands.send;
+    if (!template) {
+      throw commandFailureError(
+        this.selection.provider,
+        kind,
+        { reason: `Provider ${this.selection.provider} does not support ${kind}` },
+        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER
+      );
+    }
+
+    const args = applyCommandArgsTemplate(template.args, { sessionId, message });
+    const result = await this.commandRunner.run(template.command, args, {
+      interactive: kind === 'attach',
+      timeoutMs: kind === 'send' ? 15_000 : undefined
+    });
+
+    if (result.exitCode === 0) {
+      return;
+    }
+
+    const details = {
+      command: template.command,
+      args,
+      exit_code: result.exitCode,
+      signal: result.signal,
+      error_code: result.errorCode
+    };
+    if (result.exitCode === 127 || result.errorCode === 'ENOENT') {
+      throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
+    }
+    throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.INTERNAL_ERROR);
+  }
 }

package/apps/control-plane/src/supervisor/build-wave-executor.ts

@@ -1,19 +1,28 @@
-import { STATUS, TOOLS } from '../core/constants.js';
+import { GATE_RESULT, STATUS, TOOLS } from '../core/constants.js';
 import type { FeatureStatePayload, SupervisorToolCaller } from './types.js';
 import { NOOP_WORKER_DECISION_RUNNER, type WorkerDecisionRunner } from './worker-decision-loop.js';
+import type { GateRepairContext, ReactionsService } from '../application/services/reactions-service.js';
+
+interface GatesRunData {
+  overall?: string;
+  evidence_path?: string;
+}
 
 interface BuildWaveExecutorDependencies {
   toolCaller: SupervisorToolCaller;
   workerDecisionRunner?: WorkerDecisionRunner;
+  reactionsService?: ReactionsService;
 }
 
 export class BuildWaveExecutor {
   private readonly toolCaller: SupervisorToolCaller;
   private readonly workerDecisionRunner: WorkerDecisionRunner;
+  private readonly reactionsService: ReactionsService | undefined;
 
   constructor(dependencies: BuildWaveExecutorDependencies) {
     this.toolCaller = dependencies.toolCaller;
     this.workerDecisionRunner = dependencies.workerDecisionRunner ?? NOOP_WORKER_DECISION_RUNNER;
+    this.reactionsService = dependencies.reactionsService;
   }
 
   async run(featureIds: string[], maxParallelGateRuns: number): Promise<void> {
@@ -42,13 +51,125 @@ export class BuildWaveExecutor {
       });
     }
 
-    const executing = selected.map((featureId) =>
-      this.toolCaller.callTool('builder', TOOLS.GATES_RUN, {
-        feature_id: featureId,
-        profile: null,
-        mode: 'fast'
-      })
-    );
+    const executing = selected.map(async (featureId) => {
+      const stateForRetry = await this.toolCaller.callTool<FeatureStatePayload>('builder', TOOLS.FEATURE_STATE_GET, {
+        feature_id: featureId
+      });
+      const initialRetryCount = stateForRetry.data.front_matter.gate_retry_count ?? 0;
+
+      let gateOverall: string;
+      let gateExitCode: number;
+      let gateEvidencePath = '';
+      let gateLogs = '';
+      const failureHistory: GateRepairContext['failureHistory'] = [];
+
+      try {
+        const gateResult = await this.toolCaller.callTool<GatesRunData>('builder', TOOLS.GATES_RUN, {
+          feature_id: featureId,
+          profile: null,
+          mode: 'fast'
+        });
+        gateOverall = gateResult.data.overall ?? GATE_RESULT.PASS;
+        gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
+        gateEvidencePath = gateResult.data.evidence_path ?? '';
+      } catch (error) {
+        gateOverall = GATE_RESULT.FAIL;
+        gateExitCode = 1;
+        const typed = error as { message?: string };
+        gateLogs = typed.message ?? '';
+      }
+
+      if (gateOverall === GATE_RESULT.FAIL) {
+        failureHistory.push({
+          attempt: initialRetryCount + 1,
+          gate_name: 'fast',
+          exit_code: gateExitCode,
+          evidence_summary: gateEvidencePath,
+          logs_excerpt: gateLogs.slice(0, 800),
+          failed_at: new Date().toISOString(),
+          retry_delay_ms: this.reactionsService?.retryDelayMs()
+        });
+      }
+
+      if (this.reactionsService && gateOverall === GATE_RESULT.FAIL) {
+        const context = await this.toolCaller.callTool('builder', TOOLS.FEATURE_GET_CONTEXT, {
+          feature_id: featureId
+        });
+        let retryCount = initialRetryCount;
+        const retryDelayMs = this.reactionsService.retryDelayMs();
+        while (this.reactionsService.shouldRetry(featureId, retryCount)) {
+          if (typeof this.reactionsService.waitBeforeRetry === 'function') {
+            await this.reactionsService.waitBeforeRetry();
+          }
+          const attempt = retryCount + 2;
+          const ctx: GateRepairContext = {
+            featureId,
+            gateName: 'fast',
+            exitCode: gateExitCode,
+            logs: gateLogs,
+            evidenceSummary: gateEvidencePath,
+            retryCount,
+            failureHistory
+          };
+          const repairPrompt = this.reactionsService.buildRepairPrompt(ctx);
+          await this.workerDecisionRunner.execute({
+            role: 'builder',
+            featureId,
+            contextBundle: context.data,
+            instructions: repairPrompt
+          });
+
+          try {
+            const retryResult = await this.toolCaller.callTool<GatesRunData>('builder', TOOLS.GATES_RUN, {
+              feature_id: featureId,
+              profile: null,
+              mode: 'fast'
+            });
+            gateOverall = retryResult.data.overall ?? GATE_RESULT.PASS;
+            gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
+            gateEvidencePath = retryResult.data.evidence_path ?? gateEvidencePath;
+            gateLogs = '';
+          } catch (error) {
+            gateOverall = GATE_RESULT.FAIL;
+            gateExitCode = 1;
+            const typed = error as { message?: string };
+            gateLogs = typed.message ?? '';
+          }
+
+          retryCount += 1;
+          await this.reactionsService.recordRetry(featureId, retryCount);
+
+          if (gateOverall === GATE_RESULT.FAIL) {
+            failureHistory.push({
+              attempt,
+              gate_name: 'fast',
+              exit_code: gateExitCode,
+              evidence_summary: gateEvidencePath,
+              logs_excerpt: gateLogs.slice(0, 800),
+              failed_at: new Date().toISOString(),
+              retry_delay_ms: retryDelayMs
+            });
+          }
+
+          if (gateOverall === GATE_RESULT.PASS) {
+            break;
+          }
+        }
+
+        if (gateOverall === GATE_RESULT.FAIL && this.reactionsService.shouldEscalate(retryCount)) {
+          const escalateCtx: GateRepairContext = {
+            featureId,
+            gateName: 'fast',
+            exitCode: gateExitCode,
+            logs: gateLogs,
+            evidenceSummary: gateEvidencePath,
+            retryCount,
+            failureHistory
+          };
+          await this.reactionsService.notifyEscalation(featureId, escalateCtx);
+        }
+      }
+    });
 
     await Promise.allSettled(executing);
   }

package/apps/control-plane/src/supervisor/qa-wave-executor.ts

@@ -1,4 +1,4 @@
-import { STATUS, TOOLS } from '../core/constants.js';
+import { GATE_RESULT, STATUS, TOOLS } from '../core/constants.js';
 import type { WorkerProvider } from '../providers/providers.js';
 import type {
   AgentPromptProvider,
@@ -10,6 +10,12 @@ import type {
 } from './types.js';
 import { UNASSIGNED_SESSION_ID } from './types.js';
 import { NOOP_WORKER_DECISION_RUNNER, type WorkerDecisionRunner } from './worker-decision-loop.js';
+import type { GateRepairContext, ReactionsService } from '../application/services/reactions-service.js';
+
+interface GatesRunData {
+  overall?: string;
+  evidence_path?: string;
+}
 
 interface QaWaveExecutorDependencies {
   kernel: FeatureOrchestrationPort;
@@ -19,6 +25,7 @@ interface QaWaveExecutorDependencies {
   featureClusterPatcher: FeatureClusterPatcher;
   state: SupervisorRuntimeState;
   workerDecisionRunner?: WorkerDecisionRunner;
+  reactionsService?: ReactionsService;
 }
 
 export class QaWaveExecutor {
@@ -29,6 +36,7 @@ export class QaWaveExecutor {
   private readonly featureClusterPatcher: FeatureClusterPatcher;
   private readonly state: SupervisorRuntimeState;
   private readonly workerDecisionRunner: WorkerDecisionRunner;
+  private readonly reactionsService: ReactionsService | undefined;
 
   constructor(dependencies: QaWaveExecutorDependencies) {
     this.kernel = dependencies.kernel;
@@ -38,6 +46,7 @@ export class QaWaveExecutor {
     this.featureClusterPatcher = dependencies.featureClusterPatcher;
     this.state = dependencies.state;
     this.workerDecisionRunner = dependencies.workerDecisionRunner ?? NOOP_WORKER_DECISION_RUNNER;
+    this.reactionsService = dependencies.reactionsService;
   }
 
   async run(featureIds: string[], maxParallelGateRuns: number): Promise<void> {
@@ -64,11 +73,120 @@ export class QaWaveExecutor {
           'Emit PATCH outputs for deterministic QA remediations, NOTE outputs for findings, and REQUEST outputs for lock/context needs.'
       });
 
-      await this.toolCaller.callTool('qa', TOOLS.GATES_RUN, {
-        feature_id: featureId,
-        profile: null,
-        mode: 'full'
+      const stateForRetry = await this.toolCaller.callTool<FeatureStatePayload>('qa', TOOLS.FEATURE_STATE_GET, {
+        feature_id: featureId
       });
+      const initialRetryCount = stateForRetry.data.front_matter.gate_retry_count ?? 0;
+
+      let gateOverall: string;
+      let gateExitCode = 0;
+      let gateEvidencePath = '';
+      let gateLogs = '';
+      const failureHistory: GateRepairContext['failureHistory'] = [];
+
+      try {
+        const gateResult = await this.toolCaller.callTool<GatesRunData>('qa', TOOLS.GATES_RUN, {
+          feature_id: featureId,
+          profile: null,
+          mode: 'full'
+        });
+        gateOverall = gateResult.data.overall ?? GATE_RESULT.PASS;
+        gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
+        gateEvidencePath = gateResult.data.evidence_path ?? '';
+      } catch (error) {
+        gateOverall = GATE_RESULT.FAIL;
+        gateExitCode = 1;
+        const typed = error as { message?: string };
+        gateLogs = typed.message ?? '';
+      }
+
+      if (gateOverall === GATE_RESULT.FAIL) {
+        failureHistory.push({
+          attempt: initialRetryCount + 1,
+          gate_name: 'full',
+          exit_code: gateExitCode,
+          evidence_summary: gateEvidencePath,
+          logs_excerpt: gateLogs.slice(0, 800),
+          failed_at: new Date().toISOString(),
+          retry_delay_ms: this.reactionsService?.retryDelayMs()
+        });
+      }
+
+      if (this.reactionsService && gateOverall === GATE_RESULT.FAIL) {
+        let retryCount = initialRetryCount;
+        const retryDelayMs = this.reactionsService.retryDelayMs();
+        while (this.reactionsService.shouldRetry(featureId, retryCount)) {
+          if (typeof this.reactionsService.waitBeforeRetry === 'function') {
+            await this.reactionsService.waitBeforeRetry();
+          }
+          const attempt = retryCount + 2;
+          const ctx: GateRepairContext = {
+            featureId,
+            gateName: 'full',
+            exitCode: gateExitCode,
+            logs: gateLogs,
+            evidenceSummary: gateEvidencePath,
+            retryCount,
+            failureHistory
+          };
+          const repairPrompt = this.reactionsService.buildRepairPrompt(ctx);
+          await this.workerDecisionRunner.execute({
+            role: 'qa',
+            featureId,
+            contextBundle: context.data,
+            instructions: repairPrompt
+          });
+
+          try {
+            const retryResult = await this.toolCaller.callTool<GatesRunData>('qa', TOOLS.GATES_RUN, {
+              feature_id: featureId,
+              profile: null,
+              mode: 'full'
+            });
+            gateOverall = retryResult.data.overall ?? GATE_RESULT.PASS;
+            gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
+            gateEvidencePath = retryResult.data.evidence_path ?? gateEvidencePath;
+            gateLogs = '';
+          } catch (error) {
+            gateOverall = GATE_RESULT.FAIL;
+            gateExitCode = 1;
+            const typed = error as { message?: string };
+            gateLogs = typed.message ?? '';
+          }
+
+          retryCount += 1;
+          await this.reactionsService.recordRetry(featureId, retryCount);
+
+          if (gateOverall === GATE_RESULT.FAIL) {
+            failureHistory.push({
+              attempt,
+              gate_name: 'full',
+              exit_code: gateExitCode,
+              evidence_summary: gateEvidencePath,
+              logs_excerpt: gateLogs.slice(0, 800),
+              failed_at: new Date().toISOString(),
+              retry_delay_ms: retryDelayMs
+            });
+          }
+
+          if (gateOverall === GATE_RESULT.PASS) {
+            break;
+          }
+        }
+
+        if (gateOverall === GATE_RESULT.FAIL && this.reactionsService.shouldEscalate(retryCount)) {
+          const escalateCtx: GateRepairContext = {
+            featureId,
+            gateName: 'full',
+            exitCode: gateExitCode,
+            logs: gateLogs,
+            evidenceSummary: gateEvidencePath,
+            retryCount,
+            failureHistory
+          };
+          await this.reactionsService.notifyEscalation(featureId, escalateCtx);
+        }
+      }
 
       const sessions = this.state.sessionsByFeature.get(featureId);
       if (sessions?.qa) {