チーム意思決定¶

// 共有メンタルモデル構築支援システムの概念的コード
class SharedMentalModelSystem {
  private team: TeamMember[];
  private sharedDocuments: SharedDocument[];
  private communicationHistory: Communication[];
  private conceptualModel: ConceptMap;

  constructor(teamMembers: TeamMember[]) {
    this.team = teamMembers;
    this.sharedDocuments = [];
    this.communicationHistory = [];
    this.conceptualModel = new ConceptMap();
  }

  // チームの共有メンタルモデルの現状を評価
  assessSharedUnderstanding(): SharedUnderstandingMetrics {
    const taskAlignment = this.evaluateTaskAlignment();
    const teamAlignment = this.evaluateTeamAlignment();
    const processAlignment = this.evaluateProcessAlignment();

    return {
      overallAlignment: (taskAlignment + teamAlignment + processAlignment) / 3,
      taskAlignment,
      teamAlignment,
      processAlignment,
      misalignmentAreas: this.identifyMisalignmentAreas(),
      recommendedActions: this.generateRecommendations()
    };
  }

  // タスク理解の一致度評価
  private evaluateTaskAlignment(): number {
    const memberTaskModels = this.team.map(member => member.getTaskModel());

    // 目標理解の一致度
    const goalAlignment = this.calculateAlignment(
      memberTaskModels.map(model => model.goals)
    );

    // 制約理解の一致度
    const constraintAlignment = this.calculateAlignment(
      memberTaskModels.map(model => model.constraints)
    );

    // 問題構造理解の一致度
    const problemAlignment = this.calculateSimilarity(
      memberTaskModels.map(model => model.problemStructure)
    );

    return (goalAlignment + constraintAlignment + problemAlignment) / 3;
  }

  // 共有理解を高めるためのセッション実施
  facilitateSharedModelSession(sessionType: SharedModelSessionType): SessionResults {
    switch (sessionType) {
      case 'conceptMapping':
        return this.facilitateConceptMappingSession();
      case 'roleDefinition':
        return this.facilitateRoleDefinitionSession();
      case 'processMapping':
        return this.facilitateProcessMappingSession();
      case 'scenarioPlanning':
        return this.facilitateScenarioPlanningSession();
      default:
        throw new Error('不明なセッションタイプ');
    }
  }

  // 概念マッピングセッションの実施
  private facilitateConceptMappingSession(): SessionResults {
    // 1. 個別概念マップの作成
    const individualMaps = this.team.map(member => 
      this.elicitConceptMap(member)
    );

    // 2. 概念マップの統合
    const integratedMap = this.integrateConceptMaps(individualMaps);

    // 3. 統合マップの検証と修正
    const validatedMap = this.validateAndRefineMap(integratedMap, this.team);

    // 4. 最終的な共有概念マップを保存
    this.conceptualModel = validatedMap;

    // 5. セッション前後での共有理解の変化を評価
    const beforeAlignment = this.previousAlignmentMetrics;
    const afterAlignment = this.assessSharedUnderstanding();

    return {
      sessionType: 'conceptMapping',
      alignmentImprovement: afterAlignment.overallAlignment - beforeAlignment.overallAlignment,
      keyInsights: this.extractKeyInsights(validatedMap, individualMaps),
      identifiedGaps: this.identifyConceptualGaps(validatedMap, individualMaps),
      actionItems: this.generateActionItems(validatedMap)
    };
  }

  // その他のセッション実施メソッド
  private facilitateRoleDefinitionSession(): SessionResults { /* 実装 */ }
  private facilitateProcessMappingSession(): SessionResults { /* 実装 */ }
  private facilitateScenarioPlanningSession(): SessionResults { /* 実装 */ }

  // 補助メソッド
  private calculateAlignment(elements: any[][]): number { /* 実装 */ }
  private calculateSimilarity(structures: any[]): number { /* 実装 */ }
  private elicitConceptMap(member: TeamMember): ConceptMap { /* 実装 */ }
  private integrateConceptMaps(maps: ConceptMap[]): ConceptMap { /* 実装 */ }
  private validateAndRefineMap(map: ConceptMap, team: TeamMember[]): ConceptMap { /* 実装 */ }
  private extractKeyInsights(shared: ConceptMap, individual: ConceptMap[]): Insight[] { /* 実装 */ }
  private identifyConceptualGaps(shared: ConceptMap, individual: ConceptMap[]): Gap[] { /* 実装 */ }
  private generateActionItems(map: ConceptMap): ActionItem[] { /* 実装 */ }
}

// 状況に応じた意思決定モデル選択システムの概念コード
class DecisionMakingModelSelector {
  private organization: Organization;
  private teamContext: TeamContext;
  private decisionProperties: DecisionProperties;

  constructor(
    organization: Organization,
    teamContext: TeamContext,
    decisionProperties: DecisionProperties
  ) {
    this.organization = organization;
    this.teamContext = teamContext;
    this.decisionProperties = decisionProperties;
  }

  // 最適な意思決定モデルの推奨
  recommendDecisionModel(): DecisionModelRecommendation {
    // 意思決定の特性評価
    const timeConstraint = this.evaluateTimeConstraint();
    const complexity = this.evaluateComplexity();
    const commitmentNeeded = this.evaluateCommitmentNeeded();
    const expertiseDistribution = this.evaluateExpertiseDistribution();
    const riskLevel = this.evaluateRiskLevel();

    // 集権的モデルが適切な条件
    if (
      timeConstraint === 'high' ||
      (complexity === 'low' && expertiseDistribution === 'centralized')
    ) {
      return {
        recommendedModel: 'centralized',
        confidenceLevel: this.calculateConfidence('centralized'),
        rationale: this.generateRationale('centralized'),
        implementation: this.generateImplementationPlan('centralized')
      };
    }

    // 協議的モデルが適切な条件
    else if (
      (timeConstraint === 'medium' || complexity === 'medium') &&
      (commitmentNeeded === 'medium' || expertiseDistribution === 'mixed')
    ) {
      return {
        recommendedModel: 'consultative',
        confidenceLevel: this.calculateConfidence('consultative'),
        rationale: this.generateRationale('consultative'),
        implementation: this.generateImplementationPlan('consultative')
      };
    }

    // 分散的モデルが適切な条件
    else if (
      (complexity === 'high' || expertiseDistribution === 'distributed') &&
      (commitmentNeeded === 'high' || this.teamContext.autonomyLevel === 'high')
    ) {
      return {
        recommendedModel: 'distributed',
        confidenceLevel: this.calculateConfidence('distributed'),
        rationale: this.generateRationale('distributed'),
        implementation: this.generateImplementationPlan('distributed')
      };
    }

    // デフォルトの推奨（ハイブリッドアプローチ）
    else {
      return {
        recommendedModel: 'hybrid',
        confidenceLevel: this.calculateConfidence('hybrid'),
        rationale: this.generateRationale('hybrid'),
        implementation: this.generateImplementationPlan('hybrid')
      };
    }
  }

  // モデル選択の詳細分析
  analyzeDecisionModelOptions(): DecisionModelAnalysis {
    const models = ['centralized', 'consultative', 'distributed', 'hybrid'];

    // 各モデルの適合性評価
    const modelEvaluations = models.map(model => {
      return {
        model,
        fitScore: this.evaluateModelFit(model),
        strengths: this.identifyStrengths(model),
        weaknesses: this.identifyWeaknesses(model),
        implementationRequirements: this.identifyRequirements(model)
      };
    });

    // 状況特性の詳細評価
    const situationalFactors = {
      timeConstraint: this.evaluateTimeConstraint(),
      complexity: this.evaluateComplexity(),
      commitmentNeeded: this.evaluateCommitmentNeeded(),
      expertiseDistribution: this.evaluateExpertiseDistribution(),
      riskLevel: this.evaluateRiskLevel(),
      organizationalCulture: this.evaluateOrganizationalCulture(),
      teamMaturity: this.evaluateTeamMaturity()
    };

    return {
      recommendedModel: this.recommendDecisionModel(),
      modelEvaluations,
      situationalFactors,
      sensitivityAnalysis: this.performSensitivityAnalysis()
    };
  }

  // 補助メソッド
  private evaluateTimeConstraint(): TimeConstraint { /* 実装 */ }
  private evaluateComplexity(): Complexity { /* 実装 */ }
  private evaluateCommitmentNeeded(): CommitmentLevel { /* 実装 */ }
  private evaluateExpertiseDistribution(): ExpertiseDistribution { /* 実装 */ }
  private evaluateRiskLevel(): RiskLevel { /* 実装 */ }
  private evaluateOrganizationalCulture(): OrganizationalCulture { /* 実装 */ }
  private evaluateTeamMaturity(): TeamMaturity { /* 実装 */ }

  private calculateConfidence(model: DecisionModel): number { /* 実装 */ }
  private generateRationale(model: DecisionModel): string { /* 実装 */ }
  private generateImplementationPlan(model: DecisionModel): ImplementationPlan { /* 実装 */ }
  private evaluateModelFit(model: DecisionModel): number { /* 実装 */ }
  private identifyStrengths(model: DecisionModel): Strength[] { /* 実装 */ }
  private identifyWeaknesses(model: DecisionModel): Weakness[] { /* 実装 */ }
  private identifyRequirements(model: DecisionModel): Requirement[] { /* 実装 */ }
  private performSensitivityAnalysis(): SensitivityAnalysis { /* 実装 */ }
}