@defai.digital/discussion-domain 13.3.0 → 13.4.0

package/src/consensus/voting.ts

@@ -8,7 +8,7 @@
  * - INV-DISC-642: Agent responses weighted by agentWeightMultiplier (default 1.5x)
  */
 
-import { DEFAULT_AGENT_WEIGHT_MULTIPLIER, type VotingResults, type VoteRecord } from '@defai.digital/contracts';
+import { DEFAULT_AGENT_WEIGHT_MULTIPLIER, DEFAULT_VOTING_SUMMARY_TIMEOUT, type VotingResults, type VoteRecord } from '@defai.digital/contracts';
 import type { ConsensusExecutor, ConsensusExecutionContext, ConsensusExecutionResult } from '../types.js';
 import {
   VOTING_TALLY,
@@ -69,6 +69,21 @@ export class VotingConsensus implements ConsensusExecutor {
       onProgress
     );
 
+    const consensusDurationMs = Date.now() - startTime;
+
+    // Emit consensus_complete event for Phase 2 tracing
+    onProgress?.({
+      type: 'consensus_complete',
+      message: `Voting consensus reached: ${votingResults.winner} won${votingResults.unanimous ? ' unanimously' : ''}`,
+      timestamp: new Date().toISOString(),
+      success: true,
+      consensusMethod: 'voting',
+      confidence: votingResults.unanimous ? 1.0 : votingResults.margin,
+      winner: votingResults.winner,
+      votes: votingResults.votes,
+      durationMs: consensusDurationMs,
+    });
+
     return {
       synthesis,
       consensus: {
@@ -77,7 +92,7 @@ export class VotingConsensus implements ConsensusExecutor {
         agreementScore: votingResults.unanimous ? 1.0 : votingResults.margin,
       },
       votingResults,
-      durationMs: Date.now() - startTime,
+      durationMs: consensusDurationMs,
       success: true,
     };
   }
@@ -185,7 +200,7 @@ export class VotingConsensus implements ConsensusExecutor {
         prompt,
         systemPrompt: getProviderSystemPrompt(synthesizerId),
         temperature: 0.5,
-        timeoutMs: 60000,
+        timeoutMs: DEFAULT_VOTING_SUMMARY_TIMEOUT, // Vote summary is simpler (90 sec default)
         abortSignal,
       });
 
@@ -193,6 +208,10 @@ export class VotingConsensus implements ConsensusExecutor {
         type: 'synthesis_complete',
         provider: synthesizerId,
         timestamp: new Date().toISOString(),
+        // Extended fields for Phase 2 tracing
+        success: result.success,
+        durationMs: result.durationMs,
+        tokenCount: result.tokenCount,
       });
 
       if (result.success && result.content) {

package/src/executor.ts

@@ -13,6 +13,7 @@
 
 import {
   DEFAULT_PROVIDERS,
+  DEFAULT_PROVIDER_TIMEOUT,
   DiscussionErrorCodes,
   createFailedDiscussionResult,
   DEFAULT_AGENT_WEIGHT_MULTIPLIER,
@@ -26,9 +27,14 @@ import type {
   DiscussionExecutorOptions,
   PatternExecutionContext,
   DiscussionProgressEvent,
+  ResolvedParticipantLike,
 } from './types.js';
 import { getPatternExecutor } from './patterns/index.js';
 import { getConsensusExecutor } from './consensus/index.js';
+import {
+  resolveParticipants,
+  getProviderIds,
+} from './participant-resolver.js';
 
 /**
  * Main discussion executor class.
@@ -40,12 +46,16 @@ export class DiscussionExecutor {
   private readonly defaultTimeoutMs: number;
   private readonly checkProviderHealth: boolean;
   private readonly traceId: string | undefined;
+  private readonly participantResolverOptions: DiscussionExecutorOptions['participantResolverOptions'];
+  private readonly cascadingConfidence: DiscussionExecutorOptions['cascadingConfidence'];
 
   constructor(options: DiscussionExecutorOptions) {
     this.providerExecutor = options.providerExecutor;
-    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 60000;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_PROVIDER_TIMEOUT;
     this.checkProviderHealth = options.checkProviderHealth ?? true;
     this.traceId = options.traceId;
+    this.participantResolverOptions = options.participantResolverOptions ?? {};
+    this.cascadingConfidence = options.cascadingConfidence;
   }
 
   /**
@@ -77,6 +87,7 @@ export class DiscussionExecutor {
       minProviders: 2,
       temperature: 0.7,
       agentWeightMultiplier: DEFAULT_AGENT_WEIGHT_MULTIPLIER,
+      fastMode: false,
     };
 
     return this.execute(config, options);
@@ -106,10 +117,39 @@ export class DiscussionExecutor {
       );
     }
 
+    // Resolve participants if provided (INV-DISC-640, INV-DISC-641)
+    let resolvedParticipants: ResolvedParticipantLike[] | undefined;
+    let providersToCheck: string[];
+
+    if (config.participants && config.participants.length > 0) {
+      // Resolve participants (agents + providers) to execution config
+      try {
+        resolvedParticipants = await resolveParticipants(config.participants, {
+          ...this.participantResolverOptions,
+          topic: config.prompt,
+          agentWeightMultiplier: config.agentWeightMultiplier,
+        });
+        // Extract unique provider IDs from resolved participants
+        providersToCheck = getProviderIds(resolvedParticipants);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createFailedDiscussionResult(
+          config.pattern,
+          config.prompt,
+          DiscussionErrorCodes.INVALID_CONFIG,
+          `Failed to resolve participants: ${errorMessage}`,
+          startedAt
+        );
+      }
+    } else {
+      // Use legacy providers array
+      providersToCheck = config.providers;
+    }
+
     // INV-DISC-100: Check provider availability
     let availableProviders: string[];
     try {
-      availableProviders = await this.checkProviders(config.providers);
+      availableProviders = await this.checkProviders(providersToCheck);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       return createFailedDiscussionResult(
@@ -143,7 +183,10 @@ export class DiscussionExecutor {
       abortSignal,
       traceId: this.traceId,
       onProgress,
-      // No cascading confidence for base executor (recursive executor handles this)
+      // Pass resolved participants for agent-aware execution
+      resolvedParticipants,
+      // Cascading confidence for early exit (INV-DISC-622, INV-DISC-623)
+      cascadingConfidence: this.cascadingConfidence,
     };
 
     // Execute pattern
@@ -293,6 +336,7 @@ export class DiscussionExecutor {
       minProviders: 3,
       temperature: 0.7,
       agentWeightMultiplier: DEFAULT_AGENT_WEIGHT_MULTIPLIER,
+      fastMode: false,
     };
 
     return this.execute(config, options);
@@ -328,6 +372,7 @@ export class DiscussionExecutor {
       minProviders: 2,
       temperature: 0.5, // Lower temperature for more consistent voting
       agentWeightMultiplier: DEFAULT_AGENT_WEIGHT_MULTIPLIER,
+      fastMode: false,
     };
 
     return this.execute(config, options);

package/src/participant-resolver.ts

@@ -203,8 +203,12 @@ export async function resolveParticipant(
       if (injection.combinedContent) {
         resolved.abilityContent = injection.combinedContent;
       }
-    } catch {
-      // Ability injection failed, continue without abilities
+    } catch (error) {
+      // Log warning for diagnostics, but don't fail discussion
+      console.warn(
+        `[participant-resolver] Ability injection failed for agent ${agentId}:`,
+        error instanceof Error ? error.message : String(error)
+      );
     }
   }
 
@@ -236,13 +240,23 @@ export function providersToParticipants(providers: string[]): DiscussionParticip
  * Parse participant string (e.g., "claude" or "reviewer:agent")
  */
 export function parseParticipantString(input: string): DiscussionParticipant {
-  const parts = input.split(':');
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error('Participant string cannot be empty');
+  }
+
+  const parts = trimmed.split(':');
+  const id = parts[0]!.trim();
+
+  if (!id) {
+    throw new Error('Participant ID cannot be empty');
+  }
 
   if (parts.length === 2 && parts[1] === 'agent') {
-    return { type: 'agent', id: parts[0]! };
+    return { type: 'agent', id };
   }
 
-  return { type: 'provider', id: parts[0]! };
+  return { type: 'provider', id };
 }
 
 /**

package/src/patterns/synthesis.ts

@@ -15,6 +15,7 @@
  */
 
 import type { DiscussionRound, DebateRole } from '@defai.digital/contracts';
+import { DEFAULT_ROUND_AGREEMENT_THRESHOLD } from '@defai.digital/contracts';
 import type {
   PatternExecutor,
   PatternExecutionContext,
@@ -28,7 +29,7 @@ import {
   formatPreviousResponses,
   getProviderSystemPrompt,
 } from '../prompts/templates.js';
-import { extractConfidence, evaluateEarlyExit } from '../confidence-extractor.js';
+import { extractConfidence, evaluateEarlyExit, calculateAgreementScore } from '../confidence-extractor.js';
 
 // Local type for discussion DiscussionProviderResponse (avoids conflict with provider/v1 DiscussionProviderResponse)
 interface DiscussionProviderResponse {
@@ -57,6 +58,9 @@ export class SynthesisPattern implements PatternExecutor {
     const failedProviders = new Set<string>();
     let earlyExit: EarlyExitInfo | undefined;
 
+    // Extract round early exit config
+    const roundEarlyExit = config.roundEarlyExit ?? { enabled: true, agreementThreshold: DEFAULT_ROUND_AGREEMENT_THRESHOLD, minRounds: 1 };
+
     // Filter to available providers
     const providers = config.providers.filter(p => availableProviders.includes(p));
 
@@ -75,7 +79,9 @@ export class SynthesisPattern implements PatternExecutor {
     onProgress?.({
       type: 'round_start',
       round: 1,
-      message: 'Gathering initial perspectives in parallel',
+      message: config.fastMode
+        ? 'Fast mode: Gathering perspectives (single round)'
+        : 'Gathering initial perspectives in parallel',
       timestamp: new Date().toISOString(),
     });
 
@@ -98,6 +104,11 @@ export class SynthesisPattern implements PatternExecutor {
       round: 1,
       message: `Initial perspectives gathered from ${initialRound.succeeded.length} providers`,
       timestamp: new Date().toISOString(),
+      // Extended fields for Phase 2 tracing
+      participatingProviders: initialRound.succeeded,
+      failedProviders: initialRound.failed,
+      responseCount: initialRound.round.responses.length,
+      durationMs: initialRound.round.durationMs,
     });
 
     // Check if enough providers participated
@@ -112,6 +123,28 @@ export class SynthesisPattern implements PatternExecutor {
       };
     }
 
+    // FAST MODE: Skip cross-discussion rounds entirely
+    if (config.fastMode) {
+      onProgress?.({
+        type: 'round_complete',
+        message: 'Fast mode: Skipping cross-discussion, proceeding to synthesis',
+        timestamp: new Date().toISOString(),
+      });
+
+      return {
+        rounds,
+        participatingProviders: Array.from(participatingProviders),
+        failedProviders: Array.from(failedProviders),
+        totalDurationMs: Date.now() - startTime,
+        success: true,
+        earlyExit: {
+          triggered: true,
+          reason: 'Fast mode enabled - single round',
+          atProviderCount: participatingProviders.size,
+        },
+      };
+    }
+
     // Check for early exit after round 1 (INV-DISC-643)
     if (cascadingConfidence?.enabled) {
       const responsesWithConfidence = initialRound.round.responses.map(r => ({
@@ -149,6 +182,34 @@ export class SynthesisPattern implements PatternExecutor {
       }
     }
 
+    // ROUND-LEVEL EARLY EXIT: Check agreement after round 1
+    if (roundEarlyExit.enabled && rounds.length >= (roundEarlyExit.minRounds ?? 1)) {
+      const agreementScore = this.calculateRoundAgreement(initialRound.round.responses);
+      const threshold = roundEarlyExit.agreementThreshold ?? DEFAULT_ROUND_AGREEMENT_THRESHOLD;
+
+      if (agreementScore >= threshold) {
+        onProgress?.({
+          type: 'round_complete',
+          message: `Round early exit: High agreement detected (${(agreementScore * 100).toFixed(0)}% >= ${(threshold * 100).toFixed(0)}%)`,
+          timestamp: new Date().toISOString(),
+        });
+
+        return {
+          rounds,
+          participatingProviders: Array.from(participatingProviders),
+          failedProviders: Array.from(failedProviders),
+          totalDurationMs: Date.now() - startTime,
+          success: true,
+          earlyExit: {
+            triggered: true,
+            reason: `High agreement after round 1 (${(agreementScore * 100).toFixed(0)}%)`,
+            atProviderCount: participatingProviders.size,
+            confidenceScore: agreementScore,
+          },
+        };
+      }
+    }
+
     // Additional rounds: Cross-discussion
     for (let roundNum = 2; roundNum <= config.rounds; roundNum++) {
       if (abortSignal?.aborted) {
@@ -180,6 +241,11 @@ export class SynthesisPattern implements PatternExecutor {
         round: roundNum,
         message: `Cross-discussion round ${roundNum} complete`,
         timestamp: new Date().toISOString(),
+        // Extended fields for Phase 2 tracing
+        participatingProviders: providers.filter(p => !crossRound.failed.includes(p)),
+        failedProviders: crossRound.failed,
+        responseCount: crossRound.round.responses.length,
+        durationMs: crossRound.round.durationMs,
       });
 
       // Check for early exit after each round
@@ -297,6 +363,11 @@ export class SynthesisPattern implements PatternExecutor {
           provider: providerId,
           message: result.success ? 'completed' : `failed: ${result.error}`,
           timestamp: new Date().toISOString(),
+          // Extended fields for Phase 2 tracing
+          success: result.success,
+          durationMs: result.durationMs,
+          tokenCount: result.tokenCount,
+          error: result.success ? undefined : result.error,
         });
 
         return response;
@@ -405,6 +476,11 @@ export class SynthesisPattern implements PatternExecutor {
           round: roundNum,
           provider: providerId,
           timestamp: new Date().toISOString(),
+          // Extended fields for Phase 2 tracing
+          success: result.success,
+          durationMs: result.durationMs,
+          tokenCount: result.tokenCount,
+          error: result.success ? undefined : result.error,
         });
 
         return response;
@@ -436,4 +512,28 @@ export class SynthesisPattern implements PatternExecutor {
       failed,
     };
   }
+
+  /**
+   * Calculate agreement score for responses in a round.
+   * Uses semantic similarity and key phrase overlap to detect consensus.
+   */
+  private calculateRoundAgreement(responses: DiscussionProviderResponse[]): number {
+    if (responses.length < 2) {
+      return 1.0; // Single response = full agreement
+    }
+
+    const successfulResponses = responses.filter(r => !r.error && r.content.length > 0);
+    if (successfulResponses.length < 2) {
+      return 0.5; // Not enough responses to compare
+    }
+
+    // Use the calculateAgreementScore function from confidence-extractor
+    const responsesForScoring = successfulResponses.map(r => ({
+      provider: r.provider,
+      content: r.content,
+      confidence: r.confidence,
+    }));
+
+    return calculateAgreementScore(responsesForScoring);
+  }
 }

package/src/recursive-executor.ts

@@ -13,6 +13,7 @@
 
 import {
   DEFAULT_PROVIDERS,
+  DEFAULT_PROVIDER_TIMEOUT,
   DiscussionErrorCodes,
   createFailedDiscussionResult,
   type DiscussStepConfig,
@@ -77,7 +78,7 @@ export class RecursiveDiscussionExecutor {
 
   constructor(options: RecursiveDiscussionExecutorOptions) {
     this.providerExecutor = options.providerExecutor;
-    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 60000;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_PROVIDER_TIMEOUT;
     this.checkProviderHealth = options.checkProviderHealth ?? true;
     this.traceId = options.traceId;
     this.parentContext = options.parentContext;
@@ -141,6 +142,7 @@ export class RecursiveDiscussionExecutor {
       minProviders: 2,
       temperature: 0.7,
       agentWeightMultiplier: DEFAULT_AGENT_WEIGHT_MULTIPLIER,
+      fastMode: false,
     };
 
     return this.execute(config, options);
@@ -288,6 +290,7 @@ export class RecursiveDiscussionExecutor {
           temperature: 0.7,
           verbose: false,
           agentWeightMultiplier: DEFAULT_AGENT_WEIGHT_MULTIPLIER,
+          fastMode: true, // Sub-discussions use fast mode
         },
         abortSignal ? { abortSignal } : {}
       );

package/src/types.ts

@@ -117,6 +117,27 @@ export interface CascadingConfidenceOptions {
 /**
  * Context passed to pattern executors
  */
+/**
+ * Resolved participant for pattern execution (subset of full type)
+ * Full type is in participant-resolver.ts
+ */
+export interface ResolvedParticipantLike {
+  /** Original participant identifier */
+  id: string;
+  /** Whether this is an agent (vs raw provider) */
+  isAgent: boolean;
+  /** Provider ID to use for LLM calls */
+  providerId: string;
+  /** Agent ID (if isAgent) */
+  agentId?: string | undefined;
+  /** System prompt override (from agent config) */
+  systemPromptOverride?: string | undefined;
+  /** Injected ability content */
+  abilityContent?: string | undefined;
+  /** Weight multiplier for consensus */
+  weightMultiplier: number;
+}
+
 export interface PatternExecutionContext {
   /** The discussion configuration */
   config: DiscussStepConfig;
@@ -138,17 +159,46 @@ export interface PatternExecutionContext {
 
   /** Cascading confidence configuration for early exit */
   cascadingConfidence?: CascadingConfidenceOptions | undefined;
+
+  /** Resolved participants including agents (when participants array is used) */
+  resolvedParticipants?: ResolvedParticipantLike[] | undefined;
 }
 
 /**
  * Progress event during discussion execution
+ * Extended with detailed data for Phase 2 trace event emission
  */
 export interface DiscussionProgressEvent {
-  type: 'round_start' | 'provider_start' | 'provider_complete' | 'round_complete' | 'synthesis_start' | 'synthesis_complete';
+  type: 'round_start' | 'provider_start' | 'provider_complete' | 'round_complete' | 'synthesis_start' | 'synthesis_complete' | 'consensus_complete';
   round?: number | undefined;
   provider?: string | undefined;
   message?: string | undefined;
   timestamp: string;
+  // Extended fields for granular tracing (Phase 2)
+  /** Provider response success status */
+  success?: boolean | undefined;
+  /** Duration in milliseconds */
+  durationMs?: number | undefined;
+  /** Token count for provider response */
+  tokenCount?: number | undefined;
+  /** Error message for failed responses */
+  error?: string | undefined;
+  /** Role in debate pattern */
+  role?: string | undefined;
+  /** Participating providers (for round_complete) */
+  participatingProviders?: string[] | undefined;
+  /** Failed providers (for round_complete) */
+  failedProviders?: string[] | undefined;
+  /** Response count (for round_complete) */
+  responseCount?: number | undefined;
+  /** Consensus method (for consensus_complete) */
+  consensusMethod?: string | undefined;
+  /** Agreement/confidence score (for consensus_complete) */
+  confidence?: number | undefined;
+  /** Vote counts (for voting consensus) */
+  votes?: Record<string, number> | undefined;
+  /** Winner (for voting consensus) */
+  winner?: string | undefined;
 }
 
 /**
@@ -283,6 +333,19 @@ export interface ConsensusExecutor {
 /**
  * Options for creating a discussion executor
  */
+/**
+ * Options for participant resolution (subset of full type)
+ * Full type is in participant-resolver.ts
+ */
+export interface ParticipantResolverOptionsLike {
+  /** Agent registry for looking up agents */
+  agentRegistry?: { get(agentId: string): Promise<{ agentId: string; systemPrompt?: string } | null> } | undefined;
+  /** Ability manager for injecting abilities */
+  abilityManager?: { injectAbilities(agentId: string, task: string, coreAbilities: string[], options: { maxAbilities: number; maxTokens: number }): Promise<{ combinedContent: string; injectedAbilities: string[] }> } | undefined;
+  /** Default provider to use when agent has no preference */
+  defaultProvider?: string | undefined;
+}
+
 export interface DiscussionExecutorOptions {
   /** Provider executor implementation */
   providerExecutor: DiscussionProviderExecutor;
@@ -295,6 +358,12 @@ export interface DiscussionExecutorOptions {
 
   /** Trace ID for debugging */
   traceId?: string | undefined;
+
+  /** Options for resolving agent participants (INV-DISC-640, INV-DISC-641) */
+  participantResolverOptions?: ParticipantResolverOptionsLike | undefined;
+
+  /** Cascading confidence config for early exit (INV-DISC-622, INV-DISC-623) */
+  cascadingConfidence?: CascadingConfidenceOptions | undefined;
 }
 
 // ============================================================================