Function bodies 601 total

  async getInventoryAtDate(targetDate: string): Promise<InventoryRow[]> {
    const client = this.getClient();
    const { data, error } = await client.rpc('get_inventory_at_date', {
      p_date: targetDate,
    });
    if (error) {
      console.error(`[SupabaseAdapter] getInventoryAtDate(${targetDate}) 실패:`, error.message);
      return [];
    }
    return (data ?? []) as InventoryRow[];
  }

  async getInventory(): Promise<InventoryRow[]> {
    return this.fetchAllPaginated<InventoryRow>('inventory', {
      orderBy: 'product_name',
      ascending: true,
    });
  }

  async upsertUtilities(rows: UtilityRow[]): Promise<number> {
    if (rows.length === 0) return 0;
    const client = this.getClient();

    const { error } = await client
      .from('utilities')
      .upsert(
        rows.map(r => ({ ...r, synced_at: new Date().toISOString() })),
        { onConflict: 'date' }
      );

    if (error) throw new Error(`utilities upsert failed: ${error.message}`);
    return rows.length;
  }

  async getUtilities(dateFrom?: string, dateTo?: string): Promise<UtilityRow[]> {
    return this.fetchAllPaginated<UtilityRow>('utilities', { dateFrom, dateTo });
  }

  async createSyncLog(log: Omit<SyncLogRow, 'id'>): Promise<string> {
    const client = this.getClient();

    const { data, error } = await client
      .from('sync_log')
      .insert(log)
      .select('id')
      .single();

    if (error) throw new Error(`sync_log insert failed: ${error.message}`);
    return data.id;
  }

  async updateSyncLog(
    id: string,
    updates: Partial<Pick<SyncLogRow, 'status' | 'records_synced' | 'error_message' | 'completed_at' | 'content_hash' | 'tables_updated'>>
  ): Promise<void> {
    const client = this.getClient();

    const { error } = await client.from('sync_log').update(updates).eq('id', id);
    if (error) throw new Error(`sync_log update failed: ${error.message}`);
  }

  async getRecentSyncLogs(limit: number = 10): Promise<SyncLogRow[]> {
    const client = this.getClient();

    const { data, error } = await client
      .from('sync_log')
      .select('*')
      .order('started_at', { ascending: false })
      .limit(limit);

    if (error) throw new Error(`sync_log query failed: ${error.message}`);
    return data || [];
  }

  async getLastSyncTime(source: string): Promise<string | null> {
    const client = this.getClient();

    const { data, error } = await client
      .from('sync_log')
      .select('completed_at')
      .eq('source', source)
      .eq('status', 'success')
      .order('completed_at', { ascending: false })
      .limit(1)
      .single();

    if (error || !data) return null;
    return data.completed_at;
  }

  async getLastContentHash(source: string): Promise<Record<string, string> | null> {
    const client = this.getClient();

    const { data, error } = await client
      .from('sync_log')
      .select('content_hash')
      .eq('source', source)
      .eq('status', 'success')
      .not('content_hash', 'is', null)
      .order('completed_at', { ascending: false })
      .limit(1)
      .single();

    if (error || !data?.content_hash) return null;
    try {
      return JSON.parse(data.content_hash);
    } catch {
      return null;
    }
  }

  async upsertLaborDaily(rows: LaborDailyRow[]): Promise<number> {
    if (rows.length === 0) return 0;
    const client = this.getClient();

    const { error } = await client
      .from('labor_daily')
      .upsert(
        rows.map(r => ({ ...r, synced_at: new Date().toISOString() })),
        { onConflict: 'date,department' }
      );

    if (error) throw new Error(`labor_daily upsert failed: ${error.message}`);
    return rows.length;
  }

  async getLaborDaily(dateFrom?: string, dateTo?: string): Promise<LaborDailyRow[]> {
    return this.fetchAllPaginated<LaborDailyRow>('labor_daily', { dateFrom, dateTo });
  }

  async upsertBom(rows: BomRow[]): Promise<number> {
    if (rows.length === 0) return 0;
    const client = this.getClient();

    // BOM 데이터가 많을 수 있으므로 배치 처리
    const batchSize = 500;
    for (let i = 0; i < rows.length; i += batchSize) {
      const batch = rows.slice(i, i + batchSize).map(r => ({
        ...r,
        synced_at: new Date().toISOString(),
      }));

      const { error } = await client
        .from('bom')
        .upsert(batch, { onConflict: 'source,product_code,material_code' });

      if (error) throw new Error(`bom upsert failed: ${error.message}`);
    }

    return rows.length;
  }

  async getBom(source?: string): Promise<BomRow[]> {
    const client = this.getClient();
    const pageSize = 1000;
    const allData: BomRow[] = [];
    let from = 0;

    while (true) {
      let query = client
        .from('bom')
        .select('*')
        .order('product_code', { ascending: true })
        .range(from, from + pageSize - 1);

      if (source) query = query.eq('source', source);

      const { data, error } = await query;
      if (error) throw new Error(`bom query failed: ${error.message}`);
      if (!data || data.length === 0) break;

      allData.push(...data);
      if (data.length < pageSize) break;
      from += pageSize;
    }

    return allData;
  }

  async upsertMaterialMaster(rows: MaterialMasterRow[]): Promise<number> {
    if (rows.length === 0) return 0;
    const client = this.getClient();

    const { error } = await client
      .from('material_master')
      .upsert(
        rows.map(r => ({ ...r, synced_at: new Date().toISOString() })),
        { onConflict: 'material_code' }
      );

    if (error) throw new Error(`material_master upsert failed: ${error.message}`);
    return rows.length;
  }

  async getMaterialMaster(): Promise<MaterialMasterRow[]> {
    return this.fetchAllPaginated<MaterialMasterRow>('material_master', {
      orderBy: 'no',
      ascending: true,
    });
  }

  async batchUpsert(operations: {
    dailySales?: DailySalesRow[];
    salesDetail?: SalesDetailRow[];
    production?: ProductionDailyRow[];
    purchases?: PurchaseRow[];
    utilities?: UtilityRow[];
    inventory?: InventoryRow[];
  }, stopOnError = false): Promise<{ success: boolean; records: Record<string, number>; errors: string[] }> {

  async saveAgentState(agentId: string, state: Record<string, any>): Promise<void> {
    const client = this.getClient();
    const { error } = await client
      .from('agent_state')
      .upsert({
        agent_id: agentId,
        state,
        updated_at: new Date().toISOString(),
      }, { onConflict: 'agent_id' });

    if (error) {
      console.error(`[SupabaseAdapter] 에이전트 상태 저장 실패 (${agentId}):`, error.message);
    }
  }

  async loadAgentState(agentId: string): Promise<Record<string, any> | null> {
    const client = this.getClient();
    const { data, error } = await client
      .from('agent_state')
      .select('state')
      .eq('agent_id', agentId)
      .single();

    if (error || !data) return null;
    return data.state;
  }

  async getTableCounts(): Promise<Record<string, number>> {
    const client = this.getClient();
    const tables = ['daily_sales', 'sales_detail', 'production_daily', 'purchases', 'inventory', 'utilities', 'labor_daily', 'bom', 'material_master'];
    const counts: Record<string, number> = {};

    await Promise.all(tables.map(async (table) => {
      const { count, error } = await client.from(table).select('*', { count: 'exact', head: true });
      counts[table] = error ? -1 : (count ?? 0);
    }));

    return counts;
  }

  async validateSalesDetail(): Promise<{
    totalRows: number;
    zeroRecommended: number;
    negativeSupply: number;
    mismatchRows: number;
  }> {

  async validateDailySalesChannels(): Promise<{
    totalRows: number;
    mismatchRows: { date: string; channelSum: number; totalRevenue: number; diff: number }[];
  }> {

  async upsertDebate(row: import('../utils/debateSerializer.js').DebateRow): Promise<void> {
    const client = this.getClient();
    const { error } = await client
      .from('debates')
      .upsert({
        ...row,
        updated_at: new Date().toISOString(),
      }, { onConflict: 'id' });

    if (error) throw new Error(`debates upsert failed: ${error.message}`);
  }

  async getDebate(id: string): Promise<import('../utils/debateSerializer.js').DebateRow | null> {
    const client = this.getClient();
    const { data, error } = await client
      .from('debates')
      .select('*')
      .eq('id', id)
      .single();

    if (error || !data) return null;
    return data as import('../utils/debateSerializer.js').DebateRow;
  }

  async getActiveDebates(): Promise<import('../utils/debateSerializer.js').DebateRow[]> {
    const client = this.getClient();
    const { data, error } = await client
      .from('debates')
      .select('*')
      .neq('current_phase', 'complete')
      .order('started_at', { ascending: false });

    if (error || !data) return [];
    return data as import('../utils/debateSerializer.js').DebateRow[];
  }

  async getDebateHistory(limit = 100): Promise<import('../utils/debateSerializer.js').DebateRow[]> {
    const client = this.getClient();
    const { data, error } = await client
      .from('debates')
      .select('*')
      .eq('current_phase', 'complete')
      .order('completed_at', { ascending: false })
      .limit(limit);

    if (error || !data) return [];
    return data as import('../utils/debateSerializer.js').DebateRow[];
  }

export abstract class Agent {
  protected id: AgentId;
  protected status: AgentStatus = 'idle';
  protected eventBus: EventBus;
  protected stateManager: StateManager;
  protected learningRegistry: LearningRegistry;
  protected processedTasks = 0;
  protected successfulTasks = 0;
  protected totalProcessingTime = 0;
  protected currentTask?: Task;
  protected unsubscribe?: () => void;

  constructor(
    id: AgentId,
    eventBus: EventBus,
    stateManager: StateManager,
    learningRegistry: LearningRegistry
  ) {
    this.id = id;
    this.eventBus = eventBus;
    this.stateManager = stateManager;
    this.learningRegistry = learningRegistry;
  }

  /**
   * Start the agent and subscribe to events
   */
  start(): void {
    this.status = 'idle';
    this.unsubscribe = this.eventBus.subscribeAgent(this.id, this.handleMessage.bind(this));
    console.log(`Agent ${this.id} started`);
  }

  /**
   * Stop the agent
   */
  stop(): void {
    this.status = 'stopped';
    if (this.unsub

  constructor(
    id: AgentId,
    eventBus: EventBus,
    stateManager: StateManager,
    learningRegistry: LearningRegistry
  ) {
    this.id = id;
    this.eventBus = eventBus;
    this.stateManager = stateManager;
    this.learningRegistry = learningRegistry;
  }

  start(): void {
    this.status = 'idle';
    this.unsubscribe = this.eventBus.subscribeAgent(this.id, this.handleMessage.bind(this));
    console.log(`Agent ${this.id} started`);
  }

  stop(): void {
    this.status = 'stopped';
    if (this.unsubscribe) {
      this.unsubscribe();
    }
    console.log(`Agent ${this.id} stopped`);
  }

  getStatus(): AgentState {
    return {
      id: this.id,
      status: this.status,
      lastActivity: new Date(),
      processedTasks: this.processedTasks,
      successRate:
        this.processedTasks > 0
          ? Math.round((this.successfulTasks / this.processedTasks) * 100)
          : 100,
      avgProcessingTime:
        this.processedTasks > 0 ? Math.round(this.totalProcessingTime / this.processedTasks) : 0,
      currentTask: this.currentTask,
    };
  }

  protected async handleMessage(message: AgentMessage): Promise<void> {
    switch (message.type) {
      case 'TASK_ASSIGNMENT':
        await this.handleTaskAssignment(message);
        break;
      case 'COACHING_FEEDBACK':
        await this.handleCoaching(message as CoachingMessage);
        break;
      case 'INSIGHT_SHARE':
        await this.handleInsightShare(message);
        break;
      case 'DATA_REQUEST':
        await this.handleDataRequest(message);
        break;
      default:
        // Ignore other message types
        break;
    }
  }

  protected async handleTaskAssignment(message: AgentMessage): Promise<void> {
    const task = message.payload as Task;
    this.currentTask = task;
    this.status = 'processing';
    const startTime = Date.now();

    try {
      const result = await this.process(task);
      this.processedTasks++;
      this.totalProcessingTime += Date.now() - startTime;

      if (result.success) {
        this.successfulTasks++;
      }

      // Send result back to coordinator
      const sender = this.eventBus.createSender(this.id);
      sender.reply(message, 'TASK_RESULT', result);
    } catch (error) {
      console.error(`Agent ${this.id} task error:`, error);
      this.status = 'error';

      const sender = this.eventBus.createSender(this.id);
      sender.reply(message, 'TASK_RESULT', {
        taskId: task.id,
        agentId: this.id,
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error',
        processingTime: Date.now() - startTime,
      }

  protected async handleCoaching(message: CoachingMessage): Promise<void> {
    const { feedback } = message.payload;
    console.log(`Agent ${this.id} received coaching:`, feedback.suggestion);

    // Record that coaching was applied
    await this.applyCoaching(feedback);
  }

  protected async handleInsightShare(message: AgentMessage): Promise<void> {
    // Default: do nothing. Override in subclasses if needed.
  }

  protected async handleDataRequest(message: AgentMessage): Promise<void> {
    // Default: do nothing. Override in subclasses if needed.
  }

  protected publishInsight(
    domain: InsightDomain,
    title: string,
    description: string,
    options: {
      highlight?: string;
      level?: InsightLevel;
      confidence?: number;
      data?: unknown;
      actionable?: boolean;
      suggestedActions?: string[];
    } = {}
  ): AgentInsight {
    const insight: AgentInsight = {
      id: uuidv4(),
      agentId: this.id,
      domain,
      timestamp: new Date(),
      title,
      description,
      highlight: options.highlight,
      level: options.level || 'info',
      confidence: options.confidence || 0.8,
      data: options.data,
      actionable: options.actionable ?? true,
      suggestedActions: options.suggestedActions,
    };

    // Add to state manager
    this.stateManager.addInsight(insight);

    // Record for learning
    this.learningRegistry.recordOutput(this.id, insight.id, {
      type: 'reasoning',
      content: { title, description },
    });

    // Broadcast to other agents and frontend
    c

  constructor(
    id: AgentId,
    config: TrioPersonaConfig,
    eventBus: EventBus,
    stateManager: StateManager,
    learningRegistry: LearningRegistry
  ) {
    super(id, eventBus, stateManager, learningRegistry);
    this.role = config.role;
    this.team = config.team;
    this.domain = config.domain;
  }

  injectDependencies(debateManager: DebateManager, geminiAdapter: GeminiAdapter): void {
    this.debateManager = debateManager;
    this.geminiAdapter = geminiAdapter;
  }

  protected async handleMessage(message: AgentMessage): Promise<void> {
    switch (message.type) {
      case 'DEBATE_START':
        await this.handleDebateStart(message);
        break;
      case 'DEBATE_THESIS':
        await this.handleDebateThesis(message);
        break;
      case 'DEBATE_ANTITHESIS':
        await this.handleDebateAntithesis(message);
        break;
      case 'DEBATE_SYNTHESIS':
        await this.handleDebateSynthesis(message);
        break;
      default:
        await super.handleMessage(message);
    }
  }

  protected async handleDebateStart(message: AgentMessage): Promise<void> {
    if (this.role !== 'optimist') return;

    const payload = message.payload as {
      debateId: string;
      topic: string;
      contextData: unknown;
    };

    this.currentDebateId = payload.debateId;
    this.status = 'processing';
    const startTime = Date.now();

    try {
      const catsCommand = this.createCATSCommand(
        `${payload.topic}에 대한 가능성과 기회를 분석하세요.`,
        payload
      );

      const position = await this.generatePosition(payload.topic, payload.contextData, catsCommand);

      const round: DebateRound = {
        id: uuidv4(),
        debateId: payload.debateId,
        phase: 'thesis',
        role: 'optimist',
        agentId: this.id,
        content: position,
        timestamp: new Date(),
        catsCommand,
      };

      // 토론 매니저에 라운드 기록
      if (this.debateManager) {
        await this.debateManager.recordRound(payload.debateId, round);
      }

      // Pessimi

  protected async handleDebateThesis(message: AgentMessage): Promise<void> {
    if (this.role !== 'pessimist') return;

    const payload = message.payload as {
      debateId: string;
      thesis: DebateRound;
      contextData: unknown;
    };

    this.currentDebateId = payload.debateId;
    this.status = 'processing';
    const startTime = Date.now();

    try {
      const catsCommand = this.createCATSCommand(
        `낙관론(${payload.thesis.content.position})에 대한 리스크와 제약을 분석하세요.`,
        payload
      );

      const position = await this.generatePosition(
        payload.thesis.content.position,
        payload.contextData,
        catsCommand,
        [payload.thesis]
      );

      const round: DebateRound = {
        id: uuidv4(),
        debateId: payload.debateId,
        phase: 'antithesis',
        role: 'pessimist',
        agentId: this.id,
        content: position,
        timestamp: new Date(),
        catsCommand,
        respondsTo: [payload.thesis.id],
      };

  protected async handleDebateAntithesis(message: AgentMessage): Promise<void> {
    if (this.role !== 'mediator') return;

    const payload = message.payload as {
      debateId: string;
      thesis: DebateRound;
      antithesis: DebateRound;
      contextData: unknown;
    };

    this.currentDebateId = payload.debateId;
    this.status = 'processing';
    const startTime = Date.now();

    try {
      const catsCommand = this.createCATSCommand(
        `낙관론과 비관론을 종합하여 균형 잡힌 결론을 도출하세요.`,
        payload
      );

      const position = await this.generatePosition(
        `${payload.thesis.content.position} vs ${payload.antithesis.content.position}`,
        payload.contextData,
        catsCommand,
        [payload.thesis, payload.antithesis]
      );

      const round: DebateRound = {
        id: uuidv4(),
        debateId: payload.debateId,
        phase: 'synthesis',
        role: 'mediator',
        agentId: this.id,
        content: position,
        timestamp: new Date(),

  protected async handleDebateSynthesis(message: AgentMessage): Promise<void> {
    // 기본 구현: 아무것도 하지 않음
  }

  protected createCATSCommand(task: string, payload: { contextData?: unknown }): CATSCommand {
    const roleDescriptions: Record<TrioRole, string> = {
      optimist: '가능성, 확장성, 창의적 대안 제시',
      pessimist: '제약 조건, 리스크, 잠재적 실패 요인 분석',
      mediator: '두 관점을 통합하여 실행 가능한 결론 도출',
    };

    return {
      context: JSON.stringify(payload.contextData || {}).slice(0, 1000),
      agentRole: this.role,
      task: `[${this.team}] ${roleDescriptions[this.role]}. ${task}`,
      successCriteria: this.getSuccessCriteria(),
    };
  }

  protected getSuccessCriteria(): string {
    const criteria: Record<TrioRole, string> = {
      optimist:
        'position(주장), reasoning(추론), evidence(근거 배열), confidence(0-100)를 JSON으로 반환',
      pessimist:
        'position(반론), reasoning(리스크 분석), evidence(위험 요소 배열), confidence(0-100)를 JSON으로 반환',
      mediator:
        'position(종합), reasoning(균형 분석), suggestedActions(권고 조치 배열), confidence(0-100)를 JSON으로 반환',
    };
    return criteria[this.role];
  }

  async process(task: Task): Promise<TaskResult> {
    // 토론 외 일반 태스크 처리
    return {
      taskId: task.id,
      agentId: this.id,
      success: true,
      output: { message: `${this.role} persona processed task` },
      processingTime: 0,
    };
  }

  getCapabilities(): string[] {
    const baseCapabilities = [
      'dialectical_debate',
      'cats_command_execution',
      `${this.role}_perspective`,
    ];

    const roleCapabilities: Record<TrioRole, string[]> = {
      optimist: ['opportunity_analysis', 'growth_projection', 'innovation_proposal'],
      pessimist: ['risk_assessment', 'constraint_analysis', 'failure_mode_detection'],
      mediator: ['synthesis_generation', 'consensus_building', 'action_planning'],
    };

    return [...baseCapabilities, ...roleCapabilities[this.role]];
  }

  protected async applyCoaching(feedback: CoachingMessage['payload']['feedback']): Promise<void> {
    console.log(`[${this.id}] 코칭 적용: ${feedback.suggestion}`);

    switch (feedback.metric) {
      case 'accuracy':
        // 정확도 개선을 위한 신뢰도 조정
        if (feedback.score < feedback.benchmark) {
          this.confidenceAdjustment -= 5;
        } else {
          this.confidenceAdjustment += 2;
        }
        break;

      case 'latency':
        // 응답 속도 개선을 위한 상세도 조정
        if (feedback.score > feedback.benchmark) {
          this.verbosityLevel = 'concise';
        }
        break;

      case 'user_acceptance':
        // 사용자 수용도 개선
        if (feedback.score < feedback.benchmark) {
          this.verbosityLevel = 'detailed';
        }
        break;
    }

    // 학습 레지스트리에 기록
    this.learningRegistry.recordCoaching(this.id, '', [
      `confidenceAdjustment: ${this.confidenceAdjustment}`,
      `verbosityLevel: ${this.verbosityLevel}`,
    ]);
  }

  getRoleInfo(): {
    role: TrioRole;
    team: DomainTeam;
    domain: InsightDomain;
  } {

  protected getAdjustedConfidence(baseConfidence: number): number {
    const adjusted = baseConfidence + this.confidenceAdjustment;
    return Math.max(0, Math.min(100, adjusted));
  }