agent-relay 2.3.12 → 2.3.14

package/packages/broker-sdk/src/workflows/run.ts

@@ -1,5 +1,5 @@
 import type { AgentRelayOptions } from '../relay.js';
-import type { WorkflowRunRow } from './types.js';
+import type { TrajectoryConfig, WorkflowRunRow } from './types.js';
 import { WorkflowRunner, type WorkflowEventListener, type VariableContext } from './runner.js';
 
 /**
@@ -16,6 +16,8 @@ export interface RunWorkflowOptions {
   relay?: AgentRelayOptions;
   /** Progress callback for workflow events. */
   onEvent?: WorkflowEventListener;
+  /** Override trajectory config. Set to false to disable trajectory recording. */
+  trajectories?: TrajectoryConfig | false;
 }
 
 /**
@@ -43,5 +45,11 @@ export async function runWorkflow(
   }
 
   const config = await runner.parseYamlFile(yamlPath);
+
+  // Allow programmatic trajectory override
+  if (options.trajectories !== undefined) {
+    config.trajectories = options.trajectories;
+  }
+
   return runner.execute(config, options.workflow, options.vars);
 }

package/packages/broker-sdk/src/workflows/runner.ts

@@ -27,12 +27,14 @@ import type {
   WorkflowStepRow,
   WorkflowStepStatus,
 } from './types.js';
+import { WorkflowTrajectory, type StepOutcome } from './trajectory.js';
 
 // ── AgentRelay SDK imports ──────────────────────────────────────────────────
 
 // Import from sub-paths to avoid pulling in the full @relaycast/sdk dependency.
 import { AgentRelay } from '../relay.js';
 import type { Agent, AgentRelayOptions } from '../relay.js';
+import { RelaycastApi } from '../relaycast.js';
 
 // ── DB adapter interface ────────────────────────────────────────────────────
 
@@ -95,6 +97,9 @@ export class WorkflowRunner {
   private readonly summaryDir: string;
 
   private relay?: AgentRelay;
+  private relaycastApi?: RelaycastApi;
+  private channel?: string;
+  private trajectory?: WorkflowTrajectory;
   private abortController?: AbortController;
   private paused = false;
   private pauseResolver?: () => void;
@@ -120,18 +125,24 @@ export class WorkflowRunner {
   private async ensureRelaycastApiKey(channel: string): Promise<void> {
     if (process.env.RELAY_API_KEY) return;
 
-    // Check cached credentials
-    const cachePath = path.join(homedir(), '.agent-relay', 'relaycast.json');
-    if (existsSync(cachePath)) {
-      try {
-        const raw = await readFile(cachePath, 'utf-8');
-        const creds = JSON.parse(raw);
-        if (creds.api_key) {
-          process.env.RELAY_API_KEY = creds.api_key;
-          return;
+    // Check cached credentials — prefer per-project cache (written by the local
+    // relay daemon) over the legacy global cache so concurrent workflows from
+    // different repos never stomp each other's credentials.
+    const projectCachePath = path.join(this.cwd, '.agent-relay', 'relaycast.json');
+    const globalCachePath = path.join(homedir(), '.agent-relay', 'relaycast.json');
+
+    for (const cachePath of [projectCachePath, globalCachePath]) {
+      if (existsSync(cachePath)) {
+        try {
+          const raw = await readFile(cachePath, 'utf-8');
+          const creds = JSON.parse(raw);
+          if (creds.api_key) {
+            process.env.RELAY_API_KEY = creds.api_key;
+            return;
+          }
+        } catch {
+          // Cache corrupt — try next path
         }
-      } catch {
-        // Cache corrupt — fall through to auto-create
       }
     }
 
@@ -159,11 +170,12 @@ export class WorkflowRunner {
       throw new Error('Relaycast workspace response missing api_key');
     }
 
-    // Cache credentials for future runs
-    const cacheDir = path.dirname(cachePath);
+    // Cache credentials in the per-project directory so concurrent workflows
+    // from different repos each get their own workspace credentials.
+    const cacheDir = path.dirname(projectCachePath);
     await mkdir(cacheDir, { recursive: true, mode: 0o700 });
     await writeFile(
-      cachePath,
+      projectCachePath,
       JSON.stringify({
         workspace_id: workspaceId,
         api_key: apiKey,
@@ -468,11 +480,19 @@ export class WorkflowRunner {
     this.abortController = new AbortController();
     this.paused = false;
 
+    // Initialize trajectory recording
+    this.trajectory = new WorkflowTrajectory(resolved.trajectories, runId, this.cwd);
+
     try {
       await this.updateRunStatus(runId, 'running');
       this.emit({ type: 'run:started', runId });
 
+      // Analyze DAG for trajectory context
+      const dagInfo = this.analyzeDAG(workflow.steps);
+      await this.trajectory.start(workflow.name, workflow.steps.length, dagInfo);
+
       const channel = resolved.swarm.channel ?? 'general';
+      this.channel = channel;
       await this.ensureRelaycastApiKey(channel);
 
       this.relay = new AgentRelay({
@@ -480,6 +500,17 @@ export class WorkflowRunner {
         channels: [channel],
       });
 
+      // Create the dedicated workflow channel and join it
+      this.relaycastApi = new RelaycastApi({
+        agentName: 'WorkflowRunner',
+        cachePath: path.join(this.cwd, '.agent-relay', 'relaycast.json'),
+      });
+      await this.relaycastApi.createChannel(channel, workflow.description);
+      await this.relaycastApi.joinChannel(channel);
+      this.postToChannel(
+        `Workflow **${workflow.name}** started — ${workflow.steps.length} steps, pattern: ${resolved.swarm.pattern}`,
+      );
+
       const agentMap = new Map<string, AgentDefinition>();
       for (const agent of resolved.agents) {
         agentMap.set(agent.name, agent);
@@ -501,11 +532,29 @@ export class WorkflowRunner {
       if (allCompleted) {
         await this.updateRunStatus(runId, 'completed');
         this.emit({ type: 'run:completed', runId });
+
+        // Complete trajectory with summary
+        const outcomes = this.collectOutcomes(stepStates, workflow.steps);
+        const summary = this.trajectory.buildRunSummary(outcomes);
+        const confidence = this.trajectory.computeConfidence(outcomes);
+        await this.trajectory.complete(summary, confidence, {
+          learnings: this.trajectory.extractLearnings(outcomes),
+          challenges: this.trajectory.extractChallenges(outcomes),
+        });
+
+        // Post rich completion report to channel
+        this.postCompletionReport(workflow.name, outcomes, summary, confidence);
       } else {
         const failedStep = [...stepStates.values()].find((s) => s.row.status === 'failed');
         const errorMsg = failedStep?.row.error ?? 'One or more steps failed';
         await this.updateRunStatus(runId, 'failed', errorMsg);
         this.emit({ type: 'run:failed', runId, error: errorMsg });
+
+        const outcomes = this.collectOutcomes(stepStates, workflow.steps);
+        this.postFailureReport(workflow.name, outcomes, errorMsg);
+
+        // Abandon trajectory on failure
+        await this.trajectory.abandon(errorMsg);
       }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
@@ -514,12 +563,19 @@ export class WorkflowRunner {
 
       if (status === 'cancelled') {
         this.emit({ type: 'run:cancelled', runId });
+        this.postToChannel(`Workflow **${workflow.name}** cancelled`);
+        await this.trajectory.abandon('Cancelled by user');
       } else {
         this.emit({ type: 'run:failed', runId, error: errorMsg });
+        this.postToChannel(`Workflow failed: ${errorMsg}`);
+        await this.trajectory.abandon(errorMsg);
       }
     } finally {
       await this.relay?.shutdown();
       this.relay = undefined;
+      this.relaycastApi = undefined;
+      this.channel = undefined;
+      this.trajectory = undefined;
       this.abortController = undefined;
     }
 
@@ -567,10 +623,21 @@ export class WorkflowRunner {
     this.abortController = new AbortController();
     this.paused = false;
 
+    // Initialize trajectory for resumed run
+    this.trajectory = new WorkflowTrajectory(config.trajectories, runId, this.cwd);
+
     try {
       await this.updateRunStatus(runId, 'running');
 
+      const pendingCount = [...stepStates.values()].filter((s) => s.row.status === 'pending').length;
+      await this.trajectory.start(
+        workflow.name,
+        workflow.steps.length,
+        `Resumed run: ${pendingCount} pending steps of ${workflow.steps.length} total`,
+      );
+
       const resumeChannel = config.swarm.channel ?? 'general';
+      this.channel = resumeChannel;
       await this.ensureRelaycastApiKey(resumeChannel);
 
       this.relay = new AgentRelay({
@@ -578,6 +645,17 @@ export class WorkflowRunner {
         channels: [resumeChannel],
       });
 
+      // Ensure channel exists and join it for resumed runs
+      this.relaycastApi = new RelaycastApi({
+        agentName: 'WorkflowRunner',
+        cachePath: path.join(this.cwd, '.agent-relay', 'relaycast.json'),
+      });
+      await this.relaycastApi.createChannel(resumeChannel);
+      await this.relaycastApi.joinChannel(resumeChannel);
+      this.postToChannel(
+        `Workflow **${workflow.name}** resumed — ${pendingCount} pending steps`,
+      );
+
       const agentMap = new Map<string, AgentDefinition>();
       for (const agent of config.agents) {
         agentMap.set(agent.name, agent);
@@ -592,19 +670,38 @@ export class WorkflowRunner {
       if (allCompleted) {
         await this.updateRunStatus(runId, 'completed');
         this.emit({ type: 'run:completed', runId });
+
+        const outcomes = this.collectOutcomes(stepStates, workflow.steps);
+        const summary = this.trajectory.buildRunSummary(outcomes);
+        const confidence = this.trajectory.computeConfidence(outcomes);
+        await this.trajectory.complete(summary, confidence, {
+          learnings: this.trajectory.extractLearnings(outcomes),
+          challenges: this.trajectory.extractChallenges(outcomes),
+        });
+
+        this.postCompletionReport(workflow.name, outcomes, summary, confidence);
       } else {
         const failedStep = [...stepStates.values()].find((s) => s.row.status === 'failed');
         const errorMsg = failedStep?.row.error ?? 'One or more steps failed';
         await this.updateRunStatus(runId, 'failed', errorMsg);
         this.emit({ type: 'run:failed', runId, error: errorMsg });
+
+        const outcomes = this.collectOutcomes(stepStates, workflow.steps);
+        this.postFailureReport(workflow.name, outcomes, errorMsg);
+        await this.trajectory.abandon(errorMsg);
       }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       await this.updateRunStatus(runId, 'failed', errorMsg);
       this.emit({ type: 'run:failed', runId, error: errorMsg });
+      this.postToChannel(`Workflow failed: ${errorMsg}`);
+      await this.trajectory.abandon(errorMsg);
     } finally {
       await this.relay?.shutdown();
       this.relay = undefined;
+      this.relaycastApi = undefined;
+      this.channel = undefined;
+      this.trajectory = undefined;
       this.abortController = undefined;
     }
 
@@ -660,23 +757,40 @@ export class WorkflowRunner {
         break;
       }
 
+      // Begin a track chapter if multiple parallel steps are starting
+      if (readySteps.length > 1 && this.trajectory) {
+        const trackNames = readySteps.map((s) => s.name).join(', ');
+        await this.trajectory.beginTrack(trackNames);
+      }
+
       const results = await Promise.allSettled(
         readySteps.map((step) =>
           this.executeStep(step, stepStates, agentMap, errorHandling, runId),
         ),
       );
 
+      // Collect outcomes from this batch for convergence reflection
+      const batchOutcomes: StepOutcome[] = [];
+
       for (let i = 0; i < results.length; i++) {
         const result = results[i];
         const step = readySteps[i];
+        const state = stepStates.get(step.name);
 
         if (result.status === 'rejected') {
           const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
-          const state = stepStates.get(step.name);
           if (state && state.row.status !== 'failed') {
             await this.markStepFailed(state, error, runId);
           }
 
+          batchOutcomes.push({
+            name: step.name,
+            agent: step.agent,
+            status: 'failed',
+            attempts: (state?.row.retryCount ?? 0) + 1,
+            error,
+          });
+
           if (strategy === 'fail-fast') {
             // Mark all pending downstream steps as skipped
             await this.markDownstreamSkipped(step.name, workflow.steps, stepStates, runId);
@@ -686,8 +800,33 @@ export class WorkflowRunner {
           if (strategy === 'continue') {
             await this.markDownstreamSkipped(step.name, workflow.steps, stepStates, runId);
           }
+        } else {
+          batchOutcomes.push({
+            name: step.name,
+            agent: step.agent,
+            status: state?.row.status === 'completed' ? 'completed' : 'failed',
+            attempts: (state?.row.retryCount ?? 0) + 1,
+            output: state?.row.output,
+            verificationPassed: state?.row.status === 'completed' && step.verification !== undefined,
+          });
         }
       }
+
+      // Reflect at convergence when a parallel batch completes
+      if (readySteps.length > 1 && this.trajectory?.shouldReflectOnConverge()) {
+        const label = readySteps.map((s) => s.name).join(' + ');
+        // Find steps that this batch unblocks
+        const completedNames = new Set(batchOutcomes.filter((o) => o.status === 'completed').map((o) => o.name));
+        const unblocked = workflow.steps
+          .filter((s) => s.dependsOn?.some((dep) => completedNames.has(dep)))
+          .filter((s) => {
+            const st = stepStates.get(s.name);
+            return st && st.row.status === 'pending';
+          })
+          .map((s) => s.name);
+
+        await this.trajectory.synthesizeAndReflect(label, batchOutcomes, unblocked.length > 0 ? unblocked : undefined);
+      }
     }
   }
 
@@ -733,11 +872,13 @@ export class WorkflowRunner {
 
       if (attempt > 0) {
         this.emit({ type: 'step:retrying', runId, stepName: step.name, attempt });
+        this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${maxRetries + 1})`);
         state.row.retryCount = attempt;
         await this.db.updateStep(state.row.id, {
           retryCount: attempt,
           updatedAt: new Date().toISOString(),
         });
+        await this.trajectory?.stepRetrying(step, attempt, maxRetries);
         await this.delay(retryDelay);
       }
 
@@ -751,6 +892,8 @@ export class WorkflowRunner {
           updatedAt: new Date().toISOString(),
         });
         this.emit({ type: 'step:started', runId, stepName: step.name });
+        this.postToChannel(`**[${step.name}]** Started (agent: ${agentDef.name})`);
+        await this.trajectory?.stepStarted(step, agentDef.name);
 
         // Resolve step-output variables (e.g. {{steps.plan.output}}) at execution time
         const stepOutputContext = this.buildStepOutputContext(stepStates);
@@ -776,13 +919,24 @@ export class WorkflowRunner {
           updatedAt: new Date().toISOString(),
         });
         this.emit({ type: 'step:completed', runId, stepName: step.name, output });
+        this.postToChannel(
+          `**[${step.name}]** Completed\n${output.slice(0, 500)}${output.length > 500 ? '\n...(truncated)' : ''}`,
+        );
+        await this.trajectory?.stepCompleted(step, output, attempt + 1);
         return;
       } catch (err) {
         lastError = err instanceof Error ? err.message : String(err);
       }
     }
 
-    // All retries exhausted — mark failed and throw so callers can apply error strategy
+    // All retries exhausted — record decision and mark failed
+    await this.trajectory?.stepFailed(step, lastError ?? 'Unknown error', maxRetries + 1, maxRetries);
+    await this.trajectory?.decide(
+      `How to handle ${step.name} failure`,
+      'exhausted',
+      `All ${maxRetries + 1} attempts failed: ${lastError ?? 'Unknown error'}`,
+    );
+    this.postToChannel(`**[${step.name}]** Failed: ${lastError ?? 'Unknown error'}`);
     await this.markStepFailed(state, lastError ?? 'Unknown error', runId);
     throw new Error(`Step "${step.name}" failed after ${maxRetries} retries: ${lastError ?? 'Unknown error'}`);
   }
@@ -796,33 +950,85 @@ export class WorkflowRunner {
       throw new Error('AgentRelay not initialized');
     }
 
+    // Append self-termination instructions to the task
+    const agentName = `${step.name}-${this.generateShortId()}`;
+    const taskWithExit = step.task + '\n\n---\n' +
+      'IMPORTANT: When you have fully completed this task, you MUST self-terminate by calling ' +
+      `the MCP tool: remove_agent(name="${agentName}", reason="Task completed"). ` +
+      'Do not wait for further input — release yourself immediately after finishing.';
+
+    const agentChannels = this.channel ? [this.channel] : agentDef.channels;
+
     const agent = await this.relay.spawnPty({
-      name: `${step.name}-${this.generateShortId()}`,
+      name: agentName,
       cli: agentDef.cli,
       args: agentDef.constraints?.model ? ['--model', agentDef.constraints.model] : [],
-      channels: agentDef.channels,
+      channels: agentChannels,
+      task: taskWithExit,
       idleThresholdSecs: agentDef.constraints?.idleThresholdSecs,
     });
 
-    // Send the task as a message to the agent
-    const system = this.relay.human({ name: 'WorkflowRunner' });
-    await system.sendMessage({ to: agent.name, text: step.task });
+    // Register the spawned agent in Relaycast for observability + start heartbeat
+    let stopHeartbeat: (() => void) | undefined;
+    if (this.relaycastApi) {
+      const agentClient = await this.relaycastApi.registerExternalAgent(
+        agent.name,
+        `Workflow agent for step "${step.name}" (${agentDef.cli})`,
+      ).catch(() => null);
+
+      // Keep the agent online in the dashboard while it's working
+      if (agentClient) {
+        stopHeartbeat = this.relaycastApi.startHeartbeat(agentClient);
+      }
+    }
 
-    // Wait for agent to exit
+    // Invite the spawned agent to the workflow channel
+    if (this.channel && this.relaycastApi) {
+      await this.relaycastApi.inviteToChannel(this.channel, agent.name).catch(() => {});
+    }
+
+    // Post task assignment to channel for observability
+    const taskPreview = step.task.slice(0, 500) + (step.task.length > 500 ? '...' : '');
+    this.postToChannel(`**[${step.name}]** Assigned to \`${agent.name}\`:\n${taskPreview}`);
+
+    // Task was already delivered as initial_task via spawnPty above.
+
+    // Wait for agent to exit (self-termination via /exit)
     const exitResult = await agent.waitForExit(timeoutMs);
 
+    // Stop heartbeat now that agent has exited
+    stopHeartbeat?.();
+
     if (exitResult === 'timeout') {
-      await agent.release();
-      throw new Error(`Step "${step.name}" timed out after ${timeoutMs}ms`);
+      // Safety net: check if the verification file exists before giving up.
+      // The agent may have completed work but failed to /exit.
+      if (step.verification?.type === 'file_exists') {
+        const verifyPath = path.resolve(this.cwd, step.verification.value);
+        if (existsSync(verifyPath)) {
+          this.postToChannel(
+            `**[${step.name}]** Agent idle after completing work — releasing`,
+          );
+          await agent.release();
+          // Fall through to read output below
+        } else {
+          await agent.release();
+          throw new Error(`Step "${step.name}" timed out after ${timeoutMs}ms`);
+        }
+      } else {
+        await agent.release();
+        throw new Error(`Step "${step.name}" timed out after ${timeoutMs}ms`);
+      }
     }
 
     // Read output from summary file if it exists
     const summaryPath = path.join(this.summaryDir, `${step.name}.md`);
-    if (existsSync(summaryPath)) {
-      return await readFile(summaryPath, 'utf-8');
-    }
+    const output = existsSync(summaryPath)
+      ? await readFile(summaryPath, 'utf-8')
+      : exitResult === 'timeout'
+        ? 'Agent completed (released after idle timeout)'
+        : `Agent exited (${exitResult})`;
 
-    return `Agent exited (${exitResult})`;
+    return output;
   }
 
   // ── Verification ────────────────────────────────────────────────────────
@@ -912,6 +1118,13 @@ export class WorkflowRunner {
               updatedAt: new Date().toISOString(),
             });
             this.emit({ type: 'step:skipped', runId, stepName: step.name });
+            this.postToChannel(`**[${step.name}]** Skipped — upstream dependency "${current}" failed`);
+            await this.trajectory?.stepSkipped(step, `Upstream dependency "${current}" failed`);
+            await this.trajectory?.decide(
+              `Whether to skip ${step.name}`,
+              'skip',
+              `Upstream dependency "${current}" failed`,
+            );
             queue.push(step.name);
           }
         }
@@ -938,6 +1151,114 @@ export class WorkflowRunner {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  // ── Channel messaging ──────────────────────────────────────────────────
+
+  /** Post a message to the workflow channel. Fire-and-forget — never throws or blocks. */
+  private postToChannel(text: string): void {
+    if (!this.relaycastApi || !this.channel) return;
+    this.relaycastApi.sendToChannel(this.channel, text).catch(() => {
+      // Non-critical — don't break workflow execution
+    });
+  }
+
+  /** Post a rich completion report to the channel. */
+  private postCompletionReport(
+    workflowName: string,
+    outcomes: StepOutcome[],
+    summary: string,
+    confidence: number,
+  ): void {
+    const completed = outcomes.filter((o) => o.status === 'completed');
+    const skipped = outcomes.filter((o) => o.status === 'skipped');
+    const retried = outcomes.filter((o) => o.attempts > 1);
+
+    const lines: string[] = [
+      `## Workflow **${workflowName}** — Complete`,
+      '',
+      summary,
+      `Confidence: ${Math.round(confidence * 100)}%`,
+      '',
+      '### Steps',
+      ...completed.map((o) =>
+        `- **${o.name}** (${o.agent}) — passed${o.verificationPassed ? ' (verified)' : ''}${o.attempts > 1 ? ` after ${o.attempts} attempts` : ''}`,
+      ),
+      ...skipped.map((o) => `- **${o.name}** — skipped`),
+    ];
+
+    if (retried.length > 0) {
+      lines.push('', '### Retries');
+      for (const o of retried) {
+        lines.push(`- ${o.name}: ${o.attempts} attempts`);
+      }
+    }
+
+    this.postToChannel(lines.join('\n'));
+  }
+
+  /** Post a failure report to the channel. */
+  private postFailureReport(
+    workflowName: string,
+    outcomes: StepOutcome[],
+    errorMsg: string,
+  ): void {
+    const completed = outcomes.filter((o) => o.status === 'completed');
+    const failed = outcomes.filter((o) => o.status === 'failed');
+    const skipped = outcomes.filter((o) => o.status === 'skipped');
+
+    const lines: string[] = [
+      `## Workflow **${workflowName}** — Failed`,
+      '',
+      `${completed.length}/${outcomes.length} steps passed. Error: ${errorMsg}`,
+      '',
+      '### Steps',
+      ...completed.map((o) => `- **${o.name}** (${o.agent}) — passed`),
+      ...failed.map((o) => `- **${o.name}** (${o.agent}) — FAILED: ${o.error ?? 'unknown'}`),
+      ...skipped.map((o) => `- **${o.name}** — skipped`),
+    ];
+
+    this.postToChannel(lines.join('\n'));
+  }
+
+  // ── Trajectory helpers ────────────────────────────────────────────────
+
+  /** Analyze DAG structure for trajectory context. */
+  private analyzeDAG(steps: WorkflowStep[]): string {
+    const roots = steps.filter((s) => !s.dependsOn?.length);
+    const withDeps = steps.filter((s) => s.dependsOn?.length);
+
+    const parts = [`Parsed ${steps.length} steps`];
+    if (roots.length > 1) {
+      parts.push(`${roots.length} parallel tracks`);
+    }
+    if (withDeps.length > 0) {
+      parts.push(`${withDeps.length} dependent steps`);
+    }
+    parts.push('DAG validated, no cycles');
+    return parts.join(', ');
+  }
+
+  /** Collect step outcomes for trajectory synthesis. */
+  private collectOutcomes(stepStates: Map<string, StepState>, steps?: WorkflowStep[]): StepOutcome[] {
+    const stepsWithVerification = new Set(
+      steps?.filter((s) => s.verification).map((s) => s.name) ?? [],
+    );
+    const outcomes: StepOutcome[] = [];
+    for (const [name, state] of stepStates) {
+      outcomes.push({
+        name,
+        agent: state.row.agentName,
+        status: state.row.status === 'completed' ? 'completed'
+          : state.row.status === 'skipped' ? 'skipped'
+          : 'failed',
+        attempts: state.row.retryCount + 1,
+        output: state.row.output,
+        error: state.row.error,
+        verificationPassed: state.row.status === 'completed' && stepsWithVerification.has(name),
+      });
+    }
+    return outcomes;
+  }
+
   // ── ID generation ─────────────────────────────────────────────────────
 
   private generateId(): string {