@defai.digital/discussion-domain 13.0.3 → 13.1.0

package/src/index.ts

@@ -10,6 +10,32 @@
 // Main executor
 export { DiscussionExecutor, createDiscussionExecutor } from './executor.js';
 
+// Recursive executor
+export {
+  RecursiveDiscussionExecutor,
+  createRecursiveDiscussionExecutor,
+  type RecursiveDiscussionResult,
+} from './recursive-executor.js';
+
+// Context tracker for recursion management
+export {
+  createContextTracker,
+  DiscussionContextError,
+  type DiscussionContextTracker,
+  type SubDiscussionCheck,
+  type ContextTrackerConfig,
+} from './context-tracker.js';
+
+// Budget manager for timeout cascade
+export {
+  createBudgetManager,
+  formatBudgetStatus,
+  recommendProvidersForBudget,
+  type DiscussionBudgetManager,
+  type BudgetAllocation,
+  type BudgetStatus,
+} from './budget-manager.js';
+
 // Types and interfaces
 export type {
   DiscussionProviderExecutor,
@@ -23,11 +49,41 @@ export type {
   ConsensusExecutionResult,
   DiscussionExecutorOptions,
   DiscussionProgressEvent,
+  // Cascading confidence types
+  CascadingConfidenceOptions,
+  EarlyExitInfo,
+  // Recursive types
+  RecursiveDiscussionExecutorOptions,
+  RecursivePatternExecutionContext,
+  RecursivePatternExecutionResult,
+  SubDiscussionRequest,
 } from './types.js';
 
 // Stub implementation for testing
 export { StubProviderExecutor } from './types.js';
 
+// Confidence extraction and early exit
+export {
+  extractConfidence,
+  evaluateEarlyExit,
+  calculateAgreementScore,
+  DEFAULT_CASCADING_CONFIDENCE,
+  type ExtractedConfidence,
+  type EarlyExitDecision,
+} from './confidence-extractor.js';
+
+// Cost tracking
+export {
+  createCostTracker,
+  formatCost,
+  formatCostSummary,
+  PROVIDER_COSTS,
+  type DiscussionCostTracker,
+  type ProviderCallRecord,
+  type CostSummary,
+  type BudgetCheckResult,
+} from './cost-tracker.js';
+
 // Pattern executors
 export {
   RoundRobinPattern,
@@ -67,3 +123,19 @@ export {
   type ProviderRegistryLike,
   type ProviderBridgeOptions,
 } from './provider-bridge.js';
+
+// Participant resolution (for agent/provider mixing)
+export {
+  resolveParticipant,
+  resolveParticipants,
+  providersToParticipants,
+  parseParticipantString,
+  parseParticipantList,
+  getProviderIds,
+  buildEnhancedSystemPrompt,
+  type ResolvedParticipant,
+  type AgentProfileLike,
+  type AgentRegistryLike,
+  type AbilityManagerLike,
+  type ParticipantResolverOptions,
+} from './participant-resolver.js';

package/src/participant-resolver.ts

@@ -0,0 +1,297 @@
+/**
+ * Participant Resolver
+ *
+ * Resolves discussion participants (providers and agents) to their execution config.
+ * Handles agent-to-provider mapping using providerAffinity.
+ *
+ * Invariants:
+ * - INV-DISC-640: Agent uses providerAffinity.preferred[0] for provider selection
+ * - INV-DISC-641: Agent abilities injected with max 10K tokens
+ * - INV-DISC-642: Agent weight multiplier between 0.5-3.0 (default 1.5)
+ */
+
+import type { DiscussionParticipant } from '@defai.digital/contracts';
+
+/**
+ * Resolved participant ready for discussion execution
+ */
+export interface ResolvedParticipant {
+  /** 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;
+
+  /** Temperature override (from agent config) */
+  temperatureOverride?: number | undefined;
+
+  /** Weight multiplier for consensus (agents typically get higher weight) */
+  weightMultiplier: number;
+}
+
+/**
+ * Agent profile interface (subset needed for resolution)
+ */
+export interface AgentProfileLike {
+  agentId: string;
+  systemPrompt?: string | undefined;
+  providerAffinity?: {
+    preferred?: string[] | undefined;
+    defaultSynthesizer?: string | undefined;
+    temperatureOverrides?: Record<string, number> | undefined;
+  } | undefined;
+  temperature?: number | undefined;
+}
+
+/**
+ * Agent registry interface for looking up agents
+ */
+export interface AgentRegistryLike {
+  get(agentId: string): Promise<AgentProfileLike | null>;
+}
+
+/**
+ * Ability manager interface for injecting abilities
+ */
+export interface AbilityManagerLike {
+  injectAbilities(
+    agentId: string,
+    task: string,
+    coreAbilities: string[],
+    options: { maxAbilities: number; maxTokens: number }
+  ): Promise<{ combinedContent: string; injectedAbilities: string[] }>;
+}
+
+/**
+ * Options for participant resolution
+ */
+export interface ParticipantResolverOptions {
+  /** Agent registry for looking up agents */
+  agentRegistry?: AgentRegistryLike | undefined;
+
+  /** Ability manager for injecting abilities */
+  abilityManager?: AbilityManagerLike | undefined;
+
+  /** Default provider to use when agent has no preference */
+  defaultProvider?: string | undefined;
+
+  /** Default weight multiplier for agent participants */
+  agentWeightMultiplier?: number | undefined;
+
+  /** Maximum tokens for ability injection */
+  maxAbilityTokens?: number | undefined;
+
+  /** Topic for ability matching */
+  topic?: string | undefined;
+}
+
+/**
+ * Default provider when agent has no preference
+ */
+const DEFAULT_PROVIDER = 'claude';
+
+/**
+ * Default agent weight multiplier (INV-DISC-642)
+ */
+const DEFAULT_AGENT_WEIGHT = 1.5;
+
+/**
+ * Maximum tokens for ability injection (INV-DISC-641)
+ */
+const DEFAULT_MAX_ABILITY_TOKENS = 10000;
+
+/**
+ * Resolve a single participant to execution config
+ */
+export async function resolveParticipant(
+  participant: DiscussionParticipant,
+  options: ParticipantResolverOptions = {}
+): Promise<ResolvedParticipant> {
+  const {
+    agentRegistry,
+    abilityManager,
+    defaultProvider = DEFAULT_PROVIDER,
+    agentWeightMultiplier = DEFAULT_AGENT_WEIGHT,
+    maxAbilityTokens = DEFAULT_MAX_ABILITY_TOKENS,
+    topic = '',
+  } = options;
+
+  // Provider participant - simple resolution
+  if (participant.type === 'provider') {
+    return {
+      id: participant.id,
+      isAgent: false,
+      providerId: participant.id,
+      weightMultiplier: 1.0, // Base weight for providers
+    };
+  }
+
+  // Agent participant - resolve via registry
+  const agentId = participant.id;
+
+  // If no registry, fall back to default provider with agent weight
+  if (!agentRegistry) {
+    return {
+      id: agentId,
+      isAgent: true,
+      providerId: defaultProvider,
+      agentId,
+      weightMultiplier: agentWeightMultiplier,
+    };
+  }
+
+  // Look up agent
+  const agent = await agentRegistry.get(agentId);
+
+  if (!agent) {
+    // Agent not found, fall back to default provider
+    return {
+      id: agentId,
+      isAgent: true,
+      providerId: defaultProvider,
+      agentId,
+      weightMultiplier: agentWeightMultiplier,
+    };
+  }
+
+  // INV-DISC-640: Use providerAffinity.preferred[0] or fallback to default
+  const providerId = agent.providerAffinity?.preferred?.[0] ?? defaultProvider;
+
+  // Get temperature override if configured
+  const temperatureOverride = agent.providerAffinity?.temperatureOverrides?.[providerId]
+    ?? agent.temperature;
+
+  // Build resolved participant
+  const resolved: ResolvedParticipant = {
+    id: agentId,
+    isAgent: true,
+    providerId,
+    agentId,
+    systemPromptOverride: agent.systemPrompt,
+    temperatureOverride,
+    weightMultiplier: agentWeightMultiplier,
+  };
+
+  // INV-DISC-641: Inject abilities if ability manager available
+  if (abilityManager && topic) {
+    try {
+      const injection = await abilityManager.injectAbilities(
+        agentId,
+        topic,
+        [], // coreAbilities
+        { maxAbilities: 5, maxTokens: maxAbilityTokens }
+      );
+
+      if (injection.combinedContent) {
+        resolved.abilityContent = injection.combinedContent;
+      }
+    } catch {
+      // Ability injection failed, continue without abilities
+    }
+  }
+
+  return resolved;
+}
+
+/**
+ * Resolve multiple participants
+ */
+export async function resolveParticipants(
+  participants: DiscussionParticipant[],
+  options: ParticipantResolverOptions = {}
+): Promise<ResolvedParticipant[]> {
+  const resolved = await Promise.all(
+    participants.map(p => resolveParticipant(p, options))
+  );
+
+  return resolved;
+}
+
+/**
+ * Convert legacy string provider list to participant array
+ */
+export function providersToParticipants(providers: string[]): DiscussionParticipant[] {
+  return providers.map(id => ({ type: 'provider' as const, id }));
+}
+
+/**
+ * Parse participant string (e.g., "claude" or "reviewer:agent")
+ */
+export function parseParticipantString(input: string): DiscussionParticipant {
+  const parts = input.split(':');
+
+  if (parts.length === 2 && parts[1] === 'agent') {
+    return { type: 'agent', id: parts[0]! };
+  }
+
+  return { type: 'provider', id: parts[0]! };
+}
+
+/**
+ * Parse participant list from CLI input
+ * Format: "claude,glm,reviewer:agent,security:agent"
+ */
+export function parseParticipantList(input: string): DiscussionParticipant[] {
+  return input
+    .split(',')
+    .map(s => s.trim())
+    .filter(s => s.length > 0)
+    .map(parseParticipantString);
+}
+
+/**
+ * Get provider IDs from resolved participants
+ */
+export function getProviderIds(participants: ResolvedParticipant[]): string[] {
+  // Unique provider IDs preserving order
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const p of participants) {
+    if (!seen.has(p.providerId)) {
+      seen.add(p.providerId);
+      result.push(p.providerId);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Build enhanced system prompt with agent context
+ */
+export function buildEnhancedSystemPrompt(
+  basePrompt: string,
+  participant: ResolvedParticipant
+): string {
+  const parts: string[] = [];
+
+  // Add ability content first (provides domain knowledge)
+  if (participant.abilityContent) {
+    parts.push(participant.abilityContent);
+    parts.push('---');
+  }
+
+  // Add agent system prompt
+  if (participant.systemPromptOverride) {
+    parts.push(participant.systemPromptOverride);
+    parts.push('---');
+  }
+
+  // Add base system prompt
+  parts.push(basePrompt);
+
+  return parts.join('\n\n');
+}

package/src/patterns/round-robin.ts

@@ -3,6 +3,9 @@
  *
  * Models respond sequentially, each building on previous responses.
  * Good for: brainstorming, iterative refinement, building consensus.
+ *
+ * Invariants:
+ * - INV-DISC-643: Early exit only after minProviders responded
  */
 
 import type { DiscussionRound, DebateRole } from '@defai.digital/contracts';
@@ -10,7 +13,9 @@ import type {
   PatternExecutor,
   PatternExecutionContext,
   PatternExecutionResult,
+  EarlyExitInfo,
 } from '../types.js';
+import { extractConfidence, evaluateEarlyExit } from '../confidence-extractor.js';
 
 // Local type for discussion ProviderResponse (avoids conflict with provider/v1 ProviderResponse)
 interface DiscussionProviderResponse {
@@ -39,12 +44,13 @@ export class RoundRobinPattern implements PatternExecutor {
 
   async execute(context: PatternExecutionContext): Promise<PatternExecutionResult> {
     const startTime = Date.now();
-    const { config, providerExecutor, availableProviders, abortSignal, onProgress } = context;
+    const { config, providerExecutor, availableProviders, abortSignal, onProgress, cascadingConfidence } = context;
 
     const rounds: DiscussionRound[] = [];
     const participatingProviders = new Set<string>();
     const failedProviders = new Set<string>();
     const allResponses: DiscussionProviderResponse[] = [];
+    let earlyExit: EarlyExitInfo | undefined;
 
     // Filter to available providers
     const providers = config.providers.filter(p => availableProviders.includes(p));
@@ -110,15 +116,20 @@ export class RoundRobinPattern implements PatternExecutor {
             abortSignal,
           });
 
+          // Extract confidence from response content
+          const content = result.success ? result.content || '' : '';
+          const confidenceResult = result.success ? extractConfidence(content) : null;
+
           const response: DiscussionProviderResponse = {
             provider: providerId,
-            content: result.success ? result.content || '' : '',
+            content,
             round: roundNum,
             timestamp: new Date().toISOString(),
             durationMs: result.durationMs,
             tokenCount: result.tokenCount,
             truncated: result.truncated,
             error: result.success ? undefined : result.error,
+            confidence: confidenceResult?.score ?? undefined,
           };
 
           roundResponses.push(response);
@@ -184,6 +195,40 @@ export class RoundRobinPattern implements PatternExecutor {
           error: `Only ${participatingProviders.size} providers succeeded, need ${config.minProviders}`,
         };
       }
+
+      // Check for early exit after each round (INV-DISC-643)
+      if (cascadingConfidence?.enabled && roundNum < config.rounds) {
+        const responsesWithConfidence = roundResponses
+          .filter(r => !r.error)
+          .map(r => ({
+            provider: r.provider,
+            content: r.content,
+            confidence: r.confidence,
+          }));
+
+        const exitDecision = evaluateEarlyExit(responsesWithConfidence, {
+          enabled: cascadingConfidence.enabled,
+          threshold: cascadingConfidence.threshold,
+          minProviders: cascadingConfidence.minProviders,
+        });
+
+        if (exitDecision.shouldExit) {
+          earlyExit = {
+            triggered: true,
+            reason: exitDecision.reason,
+            atProviderCount: exitDecision.providerCount,
+            confidenceScore: exitDecision.confidence,
+          };
+
+          onProgress?.({
+            type: 'round_complete',
+            message: `Early exit after round ${roundNum}: ${exitDecision.reason}`,
+            timestamp: new Date().toISOString(),
+          });
+
+          break; // Exit the rounds loop
+        }
+      }
     }
 
     return {
@@ -192,6 +237,7 @@ export class RoundRobinPattern implements PatternExecutor {
       failedProviders: Array.from(failedProviders),
       totalDurationMs: Date.now() - startTime,
       success: participatingProviders.size >= config.minProviders,
+      earlyExit: earlyExit ?? { triggered: false },
     };
   }
 

package/src/patterns/synthesis.ts

@@ -9,6 +9,9 @@
  * 2. Round 2: Each provider responds to others' perspectives
  * 3. (Optional) Additional cross-discussion rounds
  * 4. Final synthesis by designated synthesizer (default: claude)
+ *
+ * Invariants:
+ * - INV-DISC-643: Early exit only after minProviders responded
  */
 
 import type { DiscussionRound, DebateRole } from '@defai.digital/contracts';
@@ -16,6 +19,7 @@ import type {
   PatternExecutor,
   PatternExecutionContext,
   PatternExecutionResult,
+  EarlyExitInfo,
 } from '../types.js';
 import {
   SYNTHESIS_INITIAL,
@@ -24,6 +28,7 @@ import {
   formatPreviousResponses,
   getProviderSystemPrompt,
 } from '../prompts/templates.js';
+import { extractConfidence, evaluateEarlyExit } from '../confidence-extractor.js';
 
 // Local type for discussion DiscussionProviderResponse (avoids conflict with provider/v1 DiscussionProviderResponse)
 interface DiscussionProviderResponse {
@@ -45,11 +50,12 @@ export class SynthesisPattern implements PatternExecutor {
 
   async execute(context: PatternExecutionContext): Promise<PatternExecutionResult> {
     const startTime = Date.now();
-    const { config, providerExecutor, availableProviders, abortSignal, onProgress } = context;
+    const { config, providerExecutor, availableProviders, abortSignal, onProgress, cascadingConfidence } = context;
 
     const rounds: DiscussionRound[] = [];
     const participatingProviders = new Set<string>();
     const failedProviders = new Set<string>();
+    let earlyExit: EarlyExitInfo | undefined;
 
     // Filter to available providers
     const providers = config.providers.filter(p => availableProviders.includes(p));
@@ -106,6 +112,43 @@ export class SynthesisPattern implements PatternExecutor {
       };
     }
 
+    // Check for early exit after round 1 (INV-DISC-643)
+    if (cascadingConfidence?.enabled) {
+      const responsesWithConfidence = initialRound.round.responses.map(r => ({
+        provider: r.provider,
+        content: r.content,
+        confidence: r.confidence,
+      }));
+
+      const exitDecision = evaluateEarlyExit(responsesWithConfidence, {
+        enabled: cascadingConfidence.enabled,
+        threshold: cascadingConfidence.threshold,
+        minProviders: cascadingConfidence.minProviders,
+      });
+
+      if (exitDecision.shouldExit) {
+        onProgress?.({
+          type: 'round_complete',
+          message: `Early exit triggered: ${exitDecision.reason}`,
+          timestamp: new Date().toISOString(),
+        });
+
+        return {
+          rounds,
+          participatingProviders: Array.from(participatingProviders),
+          failedProviders: Array.from(failedProviders),
+          totalDurationMs: Date.now() - startTime,
+          success: true,
+          earlyExit: {
+            triggered: true,
+            reason: exitDecision.reason,
+            atProviderCount: exitDecision.providerCount,
+            confidenceScore: exitDecision.confidence,
+          },
+        };
+      }
+    }
+
     // Additional rounds: Cross-discussion
     for (let roundNum = 2; roundNum <= config.rounds; roundNum++) {
       if (abortSignal?.aborted) {
@@ -138,6 +181,38 @@ export class SynthesisPattern implements PatternExecutor {
         message: `Cross-discussion round ${roundNum} complete`,
         timestamp: new Date().toISOString(),
       });
+
+      // Check for early exit after each round
+      if (cascadingConfidence?.enabled && roundNum < config.rounds) {
+        const allResponses = crossRound.round.responses.map(r => ({
+          provider: r.provider,
+          content: r.content,
+          confidence: r.confidence,
+        }));
+
+        const exitDecision = evaluateEarlyExit(allResponses, {
+          enabled: cascadingConfidence.enabled,
+          threshold: cascadingConfidence.threshold,
+          minProviders: cascadingConfidence.minProviders,
+        });
+
+        if (exitDecision.shouldExit) {
+          earlyExit = {
+            triggered: true,
+            reason: exitDecision.reason,
+            atProviderCount: exitDecision.providerCount,
+            confidenceScore: exitDecision.confidence,
+          };
+
+          onProgress?.({
+            type: 'round_complete',
+            message: `Early exit after round ${roundNum}: ${exitDecision.reason}`,
+            timestamp: new Date().toISOString(),
+          });
+
+          break; // Exit the rounds loop
+        }
+      }
     }
 
     return {
@@ -146,6 +221,7 @@ export class SynthesisPattern implements PatternExecutor {
       failedProviders: Array.from(failedProviders),
       totalDurationMs: Date.now() - startTime,
       success: participatingProviders.size >= config.minProviders,
+      earlyExit: earlyExit ?? { triggered: false },
     };
   }
 
@@ -193,15 +269,20 @@ export class SynthesisPattern implements PatternExecutor {
           abortSignal,
         });
 
+        // Extract confidence from response content
+        const content = result.success ? result.content || '' : '';
+        const confidenceResult = result.success ? extractConfidence(content) : null;
+
         const response: DiscussionProviderResponse = {
           provider: providerId,
-          content: result.success ? result.content || '' : '',
+          content,
           round: roundNum,
           timestamp: new Date().toISOString(),
           durationMs: result.durationMs,
           tokenCount: result.tokenCount,
           truncated: result.truncated,
           error: result.success ? undefined : result.error,
+          confidence: confidenceResult?.score ?? undefined,
         };
 
         if (result.success) {
@@ -300,14 +381,19 @@ export class SynthesisPattern implements PatternExecutor {
           abortSignal,
         });
 
+        // Extract confidence from response content
+        const content = result.success ? result.content || '' : '';
+        const confidenceResult = result.success ? extractConfidence(content) : null;
+
         const response: DiscussionProviderResponse = {
           provider: providerId,
-          content: result.success ? result.content || '' : '',
+          content,
           round: roundNum,
           timestamp: new Date().toISOString(),
           durationMs: result.durationMs,
           tokenCount: result.tokenCount,
           error: result.success ? undefined : result.error,
+          confidence: confidenceResult?.score ?? undefined,
         };
 
         if (!result.success) {

package/src/prompts/templates.ts

@@ -335,12 +335,14 @@ export function interpolate(template: string, variables: Record<string, string>)
  * Format previous responses for inclusion in prompts
  */
 export function formatPreviousResponses(
-  responses: { provider: string; content: string; role?: DebateRole | undefined }[]
+  responses: { provider: string; content: string; role?: DebateRole | undefined; isAgent?: boolean | undefined }[]
 ): string {
   return responses
     .map(r => {
       const roleLabel = r.role ? ` (${r.role})` : '';
-      return `### ${r.provider}${roleLabel}\n${r.content}`;
+      // INV-DISC-642: Indicate agent responses for synthesis weighting
+      const agentLabel = r.isAgent ? ' [Agent - Domain Expert]' : '';
+      return `### ${r.provider}${roleLabel}${agentLabel}\n${r.content}`;
     })
     .join('\n\n');
 }