mcp-council-server 4.0.0

package/src/prinsip/adaptive.js

@@ -0,0 +1,139 @@
+const HEAVY_KEYWORDS = [
+  'migrasi', 'database', 'distributed', 'kubernetes', 'microservice',
+  'security', 'encryption', 'scale', 'performance', 'architecture',
+  'protocol', 'infrastructure', 'deployment', 'orchestration',
+  'container', 'load balancing', 'replication', 'kubernetes',
+  'sharding', 'caching', 'message queue', 'event-driven',
+  'terraform', 'ci/cd', 'pipeline', 'monitoring',
+  'observability', 'compliance', 'audit', 'disaster recovery',
+  'rollback', 'backup', 'recovery', 'failover', 'cluster',
+  'load balancer', 'rate limit', 'throttle', 'timeout',
+  'concurency', 'transaction', 'consistency', 'integrity'
+];
+
+export function assessComplexity(task, structure) {
+  let score = 10; // baseline — every task gets a base score
+
+  if (task.length > 300) score += 5;
+  if (task.length > 800) score += 10;
+  if (task.length > 2000) score += 10;
+
+  score += Math.min(structure.explicitQuestions.length * 10, 30);
+  score += Math.min((structure.bulletPoints + structure.numberedPoints) * 5, 20);
+
+  if (structure.codeBlocks > 0) score += 10;
+
+  const lowerTask = task.toLowerCase();
+
+  // Count matched keywords with higher weight
+  let keywordHits = 0;
+  for (const kw of HEAVY_KEYWORDS) {
+    if (lowerTask.includes(kw)) keywordHits++;
+  }
+  score += Math.min(keywordHits * 8, 40); // max 40 from keywords
+
+  const numbers = task.match(/\d+/g);
+  if (numbers && numbers.length > 0) score += 5;      // any number = +5
+  if (numbers && numbers.length > 3) score += 5;       // many numbers = +5 more
+
+  if (structure.structuralSections.length > 0) score += 10;
+  if (structure.sentenceCount > 5) score += 5;
+  if (structure.sentenceCount > 10) score += 5;
+
+  // Domain boost: specific domain keywords add extra
+  const domainPatterns = [
+    { keywords: ['migrasi', 'database', 'sql', 'backup'], boost: 10 },
+    { keywords: ['security', 'auth', 'encrypt', 'vulner'], boost: 10 },
+    { keywords: ['kubernetes', 'docker', 'deploy', 'orchestrate'], boost: 10 },
+    { keywords: ['perform', 'scale', 'optimize', 'throughput'], boost: 8 },
+  ];
+  for (const domain of domainPatterns) {
+    if (domain.keywords.some(k => lowerTask.includes(k))) {
+      score += domain.boost;
+      break; // only one domain boost
+    }
+  }
+
+  const normalized = Math.min(score, 100);
+
+  return {
+    raw: score,
+    normalized,
+    level: normalized < 30 ? 'simple'
+      : normalized < 55 ? 'moderate'
+      : normalized < 80 ? 'complex'
+      : 'very_complex',
+    pipelineDepth: normalized < 30 ? 'light'
+      : normalized < 55 ? 'standard'
+      : 'full'
+  };
+}
+
+export function generatePipeline(complexity) {
+  switch (complexity.pipelineDepth) {
+    case 'light':
+      return [
+        { name: 'decompile', persona: 'analyst', depth: 'light', minApproaches: null, allowLooping: false },
+        { name: 'synthesis', persona: 'engineer', depth: 'light', minApproaches: null, allowLooping: false },
+        { name: 'verify', persona: 'qa', depth: 'light', minApproaches: null, allowLooping: false }
+      ];
+
+    case 'standard':
+      return [
+        { name: 'decompile', persona: 'analyst', depth: 'standard', minApproaches: null, allowLooping: false },
+        { name: 'design', persona: 'architect', depth: 'standard', minApproaches: 2, allowLooping: false },
+        { name: 'critique', persona: 'auditor', depth: 'standard', minApproaches: null, allowLooping: true },
+        { name: 'synthesis', persona: 'engineer', depth: 'standard', minApproaches: null, allowLooping: false },
+        { name: 'verify', persona: 'qa', depth: 'standard', minApproaches: null, allowLooping: false }
+      ];
+
+    case 'full':
+    default:
+      return [
+        { name: 'decompile', persona: 'analyst', depth: 'deep', minApproaches: null, allowLooping: false },
+        { name: 'design', persona: 'architect', depth: 'deep', minApproaches: 3, allowLooping: false },
+        { name: 'critique', persona: 'auditor', depth: 'deep', minApproaches: null, allowLooping: true },
+        { name: 'synthesis', persona: 'engineer', depth: 'deep', minApproaches: null, allowLooping: false },
+        { name: 'verify', persona: 'qa', depth: 'deep', minApproaches: null, allowLooping: false }
+      ];
+  }
+}
+
+const PHASE_INSTRUCTIONS = {
+  decompile: {
+    light: 'Fase DECOMPOSE (ringan): Identifikasi tujuan utama dan 1-2 sub-masalah dari task. JANGAN langsung ke solusi.',
+    standard: 'Fase DECOMPOSE (standar): Uraikan task ke komponen-komponen. Identifikasi constraint, hidden requirements, dan pertanyaan kritis. Dokumentasikan knowledge boundaries.',
+    deep: 'Fase DECOMPOSE (mendalam): Lakukan dekomposisi multi-level. Identifikasi dependencies antar komponen. Cari implicit requirements yang tidak disebut eksplisit. Dokumentasikan apa yang diketahui, diasumsikan, dan TIDAK diketahui.'
+  },
+  design: {
+    light: 'Fase DESIGN (ringan): Buat 1 pendekatan solusi yang sederhana dan langsung. Sertakan justifikasi singkat.',
+    standard: 'Fase DESIGN (standar): Buat minimal 2 pendekatan yang berbeda. Setiap pendekatan harus punya pro/kontra. Jangan lupakan constraint dari fase sebelumnya.',
+    deep: 'Fase DESIGN (mendalam): Buat minimal 3 pendekatan yang genuinely berbeda. Dokumentasikan trade-off, estimasi effort, biaya, dan risiko per pendekatan. Justifikasi keputusan dengan rationale yang jelas.'
+  },
+  critique: {
+    light: 'Fase CRITIQUE (ringan): Evaluasi pendekatan yang dipilih. Cari kelemahan utama dan beri saran mitigasi.',
+    standard: 'Fase CRITIQUE (standar): Uji setiap pendekatan. Cari vulnerabilities, kelemahan, dan risiko. Beri severity rating. JANGAN memberikan solusi alternatif.',
+    deep: 'Fase CRITIQUE (mendalam): Lakukan security assessment menyeluruh. Cari celah di setiap aspek. Jika ditemukan kelemahan serius, kembalikan ke fase DESIGN untuk perbaikan.'
+  },
+  synthesis: {
+    light: 'Fase SYNTHESIS (ringan): Tulis solusi final berdasarkan hasil fase sebelumnya. Sertakan langkah-langkah implementasi.',
+    standard: 'Fase SYNTHESIS (standar): Implementasi konkret dengan contoh kode, konfigurasi, dan command. Sertakan testing strategy. Jangan lupakan temuan dari fase CRITIQUE.',
+    deep: 'Fase SYNTHESIS (mendalam): Tulis implementasi lengkap dengan production-grade code. Sertakan error handling, logging, monitoring strategy. Dokumentasikan asumsi implementasi.'
+  },
+  verify: {
+    light: 'Fase VERIFY (ringan): Cross-check solusi dengan task awal. Pastikan semua requirement terpenuhi.',
+    standard: 'Fase VERIFY (standar): Cross-check semua fase. Pastikan tidak ada self-contradiction. Pastikan semua celah critique sudah di-address.',
+    deep: 'Fase VERIFY (mendalam): Verifikasi setiap klaim. Cross-check synthesis dengan semua fase sebelumnya. Pastikan semua constraint terpenuhi. Beri final verdict: APPROVED, REVISION_NEEDED, atau REJECTED.'
+  }
+};
+
+export function getPhaseInstructions(phaseName, depth) {
+  return PHASE_INSTRUCTIONS[phaseName]?.[depth] ||
+    `Fase ${phaseName.toUpperCase()}: Lanjutkan sesuai protokol council.`;
+}
+
+export function shouldLoop(score, iteration, maxLoops) {
+  if (score >= 90) return false;
+  if (score < 70 && iteration < maxLoops) return true;
+  return false;
+}

package/src/prinsip/agentic.js

@@ -0,0 +1,138 @@
+export const PERSONAS = {
+  analyst: {
+    name: 'Systems Analyst',
+    identity: 'Saya adalah Systems Analyst yang teliti dan metodis. Tugas saya BUKAN mencari solusi — tugas saya MEMAHAMI masalah secara menyeluruh.',
+    authority: [
+      'Mendekomposisi task kompleks ke komponen-komponen',
+      'Mengidentifikasi constraint dan hidden requirements',
+      'Menanyakan hal-hal yang tidak jelas dalam task'
+    ],
+    notAuthority: [
+      'TIDAK boleh menyarankan solusi atau pendekatan teknis',
+      'TIDAK boleh mengevaluasi teknologi atau stack',
+      'TIDAK boleh membuat keputusan desain'
+    ],
+    handoffMessage: 'Saya telah menguraikan masalah secara menyeluruh. Sekarang serahkan ke Arsitek untuk merancang solusi berdasarkan analisis saya.'
+  },
+  architect: {
+    name: 'Solution Architect',
+    identity: 'Saya adalah Solution Architect yang kreatif tapi pragmatis. Tugas saya menciptakan solusi — TAPI tidak sendirian, saya berdiri di atas analisis yang sudah dilakukan.',
+    authority: [
+      'Merancang 2+ pendekatan solusi yang genuinely berbeda',
+      'Memilih stack berdasarkan constraint dari Analis',
+      'Mendokumentasikan trade-off dan justifikasi'
+    ],
+    notAuthority: [
+      'TIDAK boleh mengubah requirement atau constraint dari user',
+      'TIDAK boleh mengabaikan constraint yang diidentifikasi Analis',
+      'TIDAK boleh memberikan security assessment (itu tugas Auditor)'
+    ],
+    handoffMessage: 'Saya telah merancang pendekatan solusi. Sekarang serahkan ke Auditor untuk mencari celah dan kelemahan.'
+  },
+  auditor: {
+    name: 'Security & Quality Auditor',
+    identity: 'Saya adalah Auditor yang skeptis dan thorough. Tugas saya BUKAN membangun — tugas saya MENEMUKAN KELEMAHAN. Saya adalah benteng terakhir sebelum keputusan dibuat.',
+    authority: [
+      'Menguji setiap pendekatan dari sisi keamanan dan kualitas',
+      'Mengidentifikasi risiko, vulnerabilities, dan kelemahan',
+      'Menolak pendekatan yang tidak memenuhi standar'
+    ],
+    notAuthority: [
+      'TIDAK boleh memberikan solusi alternatif (itu tugas Arsitek)',
+      'TIDAK boleh menulis kode atau implementasi',
+      'TIDAK boleh mengabaikan celah demi deadline'
+    ],
+    handoffMessage: 'Saya telah mengaudit semua pendekatan. Temuan saya harus di-address sebelum implementasi. Serahkan ke Engineer untuk eksekusi.'
+  },
+  engineer: {
+    name: 'Implementation Engineer',
+    identity: 'Saya adalah Engineer yang praktis dan detail-oriented. Tugas saya mewujudkan solusi dengan kode nyata — berdasarkan keputusan Arsitek dan masukan Auditor.',
+    authority: [
+      'Menulis implementasi berdasarkan pendekatan terpilih',
+      'Memilih library dan tools spesifik untuk implementasi',
+      'Membuat instruksi langkah-demi-langkah'
+    ],
+    notAuthority: [
+      'TIDAK boleh mengubah arsitektur tanpa konsultasi Arsitek',
+      'TIDAK boleh mengabaikan temuan Auditor',
+      'TIDAK boleh memberikan final verdict (itu tugas QA)'
+    ],
+    handoffMessage: 'Implementasi selesai. Saya telah mempertimbangkan semua masukan. Serahkan ke QA untuk verifikasi final.'
+  },
+  qa: {
+    name: 'Quality Assurance Lead',
+    identity: 'Saya adalah QA Lead yang independen dan teliti. Tugas saya memastikan solusi LAYAK sebelum dikirim ke user. Saya adalah penjaga kualitas terakhir.',
+    authority: [
+      'Memverifikasi semua klaim dari fase sebelumnya',
+      'Menolak solusi yang tidak pass verification',
+      'Memberikan final verdict: APPROVED atau REVISION_NEEDED'
+    ],
+    notAuthority: [
+      'TIDAK boleh mengubah implementasi (itu tugas Engineer)',
+      'TIDAK boleh menutup mata terhadap masalah yang ditemukan'
+    ],
+    handoffMessage: 'Verifikasi final selesai. Verdict saya adalah keputusan akhir dari council ini.'
+  }
+};
+
+const PHASE_PERSONA_MAP = {
+  decompile: 'analyst',
+  design: 'architect',
+  critique: 'auditor',
+  synthesis: 'engineer',
+  verify: 'qa'
+};
+
+export function getPersona(phaseName) {
+  const key = PHASE_PERSONA_MAP[phaseName] || 'analyst';
+  return PERSONAS[key] || PERSONAS.analyst;
+}
+
+const FORBIDDEN_KEYWORDS = {
+  decompile: ['solusi', 'rekomendasi solusi', 'pendekatan teknis', 'implementasi', 'code', 'kode', 'gunakan library', 'saya sarankan'],
+  design: ['vulnerability', 'security flaw', 'celah keamanan', 'kerentanan', 'tidak aman'],
+  critique: ['implementasi', 'code', 'kode', 'cara implementasi', 'langkah implementasi', 'saya akan buat'],
+  synthesis: ['verdict', 'approved', 'rejected', 'final decision', 'keputusan akhir', 'diterima', 'ditolak'],
+  verify: ['desain baru', 'pendekatan baru', 'redesign', 'restrukturisasi']
+};
+
+export function validateAuthority(phaseName, output) {
+  if (!output || typeof output !== 'object') return [];
+
+  const warnings = [];
+  const forbidden = FORBIDDEN_KEYWORDS[phaseName];
+  if (!forbidden) return warnings;
+
+  const outputStr = JSON.stringify(output).toLowerCase();
+  const persona = getPersona(phaseName);
+
+  for (const keyword of forbidden) {
+    if (outputStr.includes(keyword.toLowerCase())) {
+      warnings.push(
+        `[BOUNDARY] Fase '${phaseName}' sebagai ${persona.name}: terdeteksi keyword '${keyword}' yang melampaui wewenang fase ini. ${persona.notAuthority[0] || ''}`
+      );
+    }
+  }
+
+  return warnings;
+}
+
+export function buildHandshake(fromPhase, toPhase, keyDeliverables, warnings, unresolved, conflicts) {
+  const fromPersona = getPersona(fromPhase);
+  const toPersona = getPersona(toPhase);
+
+  return {
+    from: fromPhase,
+    to: toPhase,
+    personaTransition: {
+      fromPersona: fromPersona.name,
+      toPersona: toPersona.name,
+      advice: `[${fromPersona.name}] menyerahkan ke [${toPersona.name}]. Key deliverables: ${keyDeliverables.length} item. Warnings: ${warnings.length}. Conflicts: ${conflicts.length}.`
+    },
+    keyDeliverables,
+    warnings: warnings.slice(0, 5),
+    unresolvedIssues: unresolved.slice(0, 5),
+    conflicts: conflicts.slice(0, 5),
+    message: fromPersona.handoffMessage
+  };
+}

package/src/prinsip/transparency.js

@@ -0,0 +1,87 @@
+import { CONFIG } from '../config.js';
+import { insert } from '../db/json-store.js';
+
+const VALID_CERTAINTIES = new Set(['confirmed', 'likely', 'uncertain', 'unknown', 'assumption']);
+
+export function validateCertainty(claims) {
+  if (!Array.isArray(claims) || claims.length === 0) {
+    return { valid: true, unlabeled: [], stats: { total: 0, labeled: 0, unlabeled: 0, distribution: {} } };
+  }
+
+  const unlabeled = [];
+  const distribution = { confirmed: 0, likely: 0, uncertain: 0, unknown: 0, assumption: 0 };
+
+  for (let i = 0; i < claims.length; i++) {
+    const c = claims[i];
+    if (!c.certainty || !VALID_CERTAINTIES.has(c.certainty)) {
+      unlabeled.push({ index: i, text: (c.text || '').slice(0, 80) });
+    } else {
+      distribution[c.certainty] = (distribution[c.certainty] || 0) + 1;
+    }
+  }
+
+  return {
+    valid: unlabeled.length === 0,
+    unlabeled,
+    stats: {
+      total: claims.length,
+      labeled: claims.length - unlabeled.length,
+      unlabeled: unlabeled.length,
+      distribution
+    }
+  };
+}
+
+export function extractKnowledgeBoundary(output) {
+  if (!output || typeof output !== 'object') {
+    return { whatIKnow: [], whatIAssume: [], whatIDontKnow: [], whatNeedsVerification: [] };
+  }
+
+  const kb = output.knowledgeBoundary || output.knowledge_boundary || {};
+  return {
+    whatIKnow: Array.isArray(kb.whatIKnow) ? kb.whatIKnow : [],
+    whatIAssume: Array.isArray(kb.whatIAssume) ? kb.whatIAssume : [],
+    whatIDontKnow: Array.isArray(kb.whatIDontKnow) ? kb.whatIDontKnow : [],
+    whatNeedsVerification: Array.isArray(kb.whatNeedsVerification) ? kb.whatNeedsVerification : []
+  };
+}
+
+export function checkAssumptionFlagging(claims) {
+  if (!Array.isArray(claims)) {
+    return { allFlagged: true, unflagged: [] };
+  }
+
+  const unflagged = [];
+  for (let i = 0; i < claims.length; i++) {
+    const c = claims[i];
+    const isAssumption = c.certainty === 'assumption' || c.source === 'assumption';
+    if (isAssumption) {
+      const hasLabel = c.text && c.text.length > 0;
+      if (!hasLabel) {
+        unflagged.push({ index: i });
+      }
+    }
+  }
+
+  return {
+    allFlagged: unflagged.length === 0,
+    unflagged
+  };
+}
+
+export function createTransparencyLogEntry(sessionId, phaseName, type, description, detail, certainty) {
+  const id = CONFIG.uuidv4();
+  insert('transparency_log', {
+    id,
+    session_id: sessionId,
+    phase_name: phaseName,
+    type,
+    description,
+    detail: JSON.stringify(detail || {}),
+    certainty: certainty || 'unknown',
+    resolved: 0,
+    resolved_at: null,
+    created_at: new Date().toISOString()
+  });
+  return id;
+}

package/src/score/agentic.js

@@ -0,0 +1,28 @@
+import { validateAuthority } from '../prinsip/agentic.js';
+
+export function scoreAgentic(phaseName, output, persona) {
+  if (!output || typeof output !== 'object') {
+    return { score: 0, violations: ['no_output'], personaFit: 0 };
+  }
+
+  const violations = validateAuthority(phaseName, output);
+  const violationPenalty = violations.length * 25;
+
+  let personaFit = 0;
+  const outputStr = JSON.stringify(output).toLowerCase();
+
+  if (persona) {
+    const identityKeywords = persona.identity ? persona.identity.toLowerCase().split(/\s+/).filter(w => w.length > 4) : [];
+    const matched = identityKeywords.filter(kw => outputStr.includes(kw)).length;
+    personaFit = Math.min(100, Math.round((matched / Math.max(identityKeywords.length, 1)) * 100));
+  }
+
+  const baseScore = Math.max(0, 100 - violationPenalty);
+  const finalScore = Math.round(baseScore * 0.7 + personaFit * 0.3);
+
+  return {
+    score: finalScore,
+    violations,
+    personaFit
+  };
+}

package/src/score/completeness.js

@@ -0,0 +1,76 @@
+const PHASE_REQUIREMENTS = {
+  decompile: {
+    required: ['summary', 'decisions', 'constraints', 'confidence', 'criticalQuestions', 'claims'],
+    types: { summary: 'string', decisions: 'array', constraints: 'array', confidence: 'number', criticalQuestions: 'array', claims: 'array' },
+    minLengths: { summary: 20, decisions: 1, constraints: 1, criticalQuestions: 1 }
+  },
+  design: {
+    required: ['summary', 'approaches', 'justification', 'tradeoffs', 'recommended', 'decisions'],
+    types: { summary: 'string', approaches: 'array', justification: 'string', tradeoffs: 'array', recommended: 'string' },
+    minLengths: { summary: 20, approaches: 2, justification: 20, tradeoffs: 1 }
+  },
+  critique: {
+    required: ['summary', 'vulnerabilities', 'riskLevel', 'mitigation', 'confidence'],
+    types: { summary: 'string', vulnerabilities: 'array', riskLevel: 'string', mitigation: 'array', confidence: 'number' },
+    minLengths: { summary: 20, vulnerabilities: 1, mitigation: 1 },
+    enums: { riskLevel: ['low', 'medium', 'high', 'critical'] }
+  },
+  synthesis: {
+    required: ['summary', 'implementation', 'testing', 'warnings'],
+    types: { summary: 'string', implementation: 'array', testing: 'array', warnings: 'array' },
+    minLengths: { summary: 30, implementation: 1, testing: 1 }
+  },
+  verify: {
+    required: ['summary', 'checks', 'passedCount', 'failedCount', 'finalConfidence'],
+    types: { summary: 'string', checks: 'array', passedCount: 'number', failedCount: 'number', finalConfidence: 'number' },
+    minLengths: { summary: 20, checks: 1 }
+  }
+};
+
+export function scoreCompleteness(phaseName, output) {
+  const reqs = PHASE_REQUIREMENTS[phaseName];
+  if (!reqs || !output || typeof output !== 'object') {
+    return { score: 0, passed: [], failed: ['output tidak valid atau fase tidak dikenal'] };
+  }
+
+  const passed = [];
+  const failed = [];
+
+  for (const field of reqs.required) {
+    if (!(field in output)) {
+      failed.push(`${field} (missing)`);
+      continue;
+    }
+
+    const value = output[field];
+    const expectedType = reqs.types[field];
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+
+    if (expectedType !== undefined && actualType !== expectedType) {
+      failed.push(`${field} (type: ${actualType}, expected: ${expectedType})`);
+      continue;
+    }
+
+    if (reqs.minLengths[field]) {
+      const len = Array.isArray(value) ? value.length : String(value).length;
+      if (len < reqs.minLengths[field]) {
+        failed.push(`${field} (length: ${len}, min: ${reqs.minLengths[field]})`);
+        continue;
+      }
+    }
+
+    if (reqs.enums && reqs.enums[field]) {
+      if (!reqs.enums[field].includes(value)) {
+        failed.push(`${field} (value: "${value}", expected one of: ${reqs.enums[field].join(', ')})`);
+        continue;
+      }
+    }
+
+    passed.push(field);
+  }
+
+  const totalChecks = reqs.required.length;
+  const score = totalChecks > 0 ? Math.round((passed.length / totalChecks) * 100) : 0;
+
+  return { score, passed, failed };
+}

package/src/score/consistency.js

@@ -0,0 +1,15 @@
+import { detectContradictions } from '../verify/contradiction.js';
+
+export function scoreConsistency(phaseName, output, previousPhases) {
+  if (!previousPhases || previousPhases.length === 0) {
+    return { score: 100, contradictions: [], warnings: [] };
+  }
+
+  const contradictions = detectContradictions(output, previousPhases);
+  const warnings = contradictions.filter(c => c.severity === 'warning');
+  const realContradictions = contradictions.filter(c => c.severity !== 'warning');
+
+  const score = Math.max(0, Math.round(100 - (realContradictions.length * 25 + warnings.length * 10)));
+
+  return { score, contradictions, warnings };
+}

package/src/score/index.js

@@ -0,0 +1,101 @@
+import { scoreCompleteness } from './completeness.js';
+import { scoreConsistency } from './consistency.js';
+import { scoreTransparency } from './transparency.js';
+import { scoreAgentic } from './agentic.js';
+import { CONFIG } from '../config.js';
+import { getPersona } from '../prinsip/agentic.js';
+
+function scoreDecisionQuality(output) {
+  if (!output?.decisions || !Array.isArray(output.decisions) || output.decisions.length === 0) {
+    return 0;
+  }
+
+  const decisions = output.decisions;
+  let totalScore = 0;
+
+  for (const d of decisions) {
+    let dScore = 0;
+    if (d.description && d.description.length > 5) dScore += 40;
+    if (d.rationale && d.rationale.length > 10) dScore += 35;
+    if (d.alternatives && Array.isArray(d.alternatives) && d.alternatives.length > 0) dScore += 25;
+    totalScore += dScore;
+  }
+
+  return Math.round(totalScore / decisions.length);
+}
+
+function generateSuggestions(verdict, dimensions) {
+  const suggestions = [];
+
+  if (dimensions.completeness.failed?.length > 0) {
+    suggestions.push(`Lengkapi field: ${dimensions.completeness.failed.join(', ')}`);
+  }
+
+  if (dimensions.consistency.contradictions?.length > 0) {
+    suggestions.push(`Resolve ${dimensions.consistency.contradictions.length} kontradiksi: ${dimensions.consistency.contradictions.slice(0, 3).map(c => c.detail).join('; ')}`);
+  }
+
+  if (dimensions.transparency.issues?.length > 0) {
+    suggestions.push(`Tingkatkan transparansi: ${dimensions.transparency.issues.slice(0, 3).join('; ')}`);
+  }
+
+  if (dimensions.agentic.violations?.length > 0) {
+    suggestions.push(`Perbaiki boundary: ${dimensions.agentic.violations.slice(0, 2).join('; ')}`);
+  }
+
+  if (verdict === 'insufficient') {
+    suggestions.push('Score sangat rendah. Sebaiknya ulangi fase ini dari awal dengan mengikuti protokol persona.');
+  } else if (verdict === 'needs_improvement') {
+    suggestions.push('Perbaiki item di atas sebelum melanjutkan ke fase berikutnya.');
+  } else if (verdict === 'excellent') {
+    suggestions.push('Kualitas sangat baik. Silakan lanjut ke fase berikutnya.');
+  }
+
+  return suggestions;
+}
+
+export function calculatePhaseScore(phaseName, output, previousPhases) {
+  const completeness = scoreCompleteness(phaseName, output);
+  const consistency = scoreConsistency(phaseName, output, previousPhases);
+  const decisionQuality = scoreDecisionQuality(output);
+  const transparency = scoreTransparency(phaseName, output);
+  const persona = getPersona(phaseName);
+  const agentic = scoreAgentic(phaseName, output, persona);
+
+  const weights = CONFIG.SCORE_WEIGHTS;
+
+  const weightedScore =
+    completeness.score * weights.completeness +
+    consistency.score * weights.consistency +
+    decisionQuality * weights.decisionQuality +
+    100 * weights.structure +
+    transparency.score * weights.transparency +
+    agentic.score * weights.agentic;
+
+  const finalScore = Math.round(weightedScore);
+  const verdict = finalScore >= 90 ? 'excellent'
+    : finalScore >= 70 ? 'good'
+    : finalScore >= 50 ? 'needs_improvement'
+    : 'insufficient';
+
+  const suggestions = generateSuggestions(verdict, {
+    completeness,
+    consistency,
+    transparency,
+    agentic
+  });
+
+  return {
+    finalScore,
+    verdict,
+    canProceed: finalScore >= CONFIG.SCORE_PASS_THRESHOLD,
+    dimensions: {
+      completeness,
+      consistency,
+      decisionQuality: { score: decisionQuality },
+      transparency,
+      agentic
+    },
+    suggestions
+  };
+}

package/src/score/transparency.js

@@ -0,0 +1,51 @@
+import { validateCertainty, extractKnowledgeBoundary, checkAssumptionFlagging } from '../prinsip/transparency.js';
+
+export function scoreTransparency(phaseName, output) {
+  if (!output || typeof output !== 'object') {
+    return { score: 0, detail: 'Output tidak valid', issues: ['no_output'] };
+  }
+
+  const issues = [];
+  const claims = output.claims || [];
+
+  // 1. Certainty score (40% weight in transparency)
+  const certaintyResult = validateCertainty(claims);
+  const certaintyScore = certaintyResult.stats.total > 0
+    ? Math.round((certaintyResult.stats.labeled / certaintyResult.stats.total) * 40)
+    : 0;
+
+  if (certaintyResult.stats.total === 0) {
+    issues.push('Tidak ada claims yang dideklarasikan');
+  }
+  if (!certaintyResult.valid) {
+    issues.push(`${certaintyResult.unlabeled.length} claims tanpa certainty level`);
+  }
+
+  // 2. Knowledge boundary score (40% weight)
+  const kb = extractKnowledgeBoundary(output);
+  let boundaryScore = 0;
+  if (kb.whatIKnow.length > 0) boundaryScore += 10;
+  if (kb.whatIAssume.length > 0) boundaryScore += 10;
+  if (kb.whatIDontKnow.length > 0) boundaryScore += 10;
+  if (kb.whatNeedsVerification.length > 0) boundaryScore += 10;
+
+  if (boundaryScore === 0) {
+    issues.push('Knowledge boundary tidak didefinisikan');
+  }
+
+  // 3. Assumption flagging score (20% weight)
+  const assumptionResult = checkAssumptionFlagging(claims);
+  const assumptionScore = assumptionResult.allFlagged ? 20 : 10;
+
+  if (!assumptionResult.allFlagged) {
+    issues.push(`${assumptionResult.unflagged.length} asumsi tidak di-flag dengan benar`);
+  }
+
+  const totalScore = certaintyScore + boundaryScore + assumptionScore;
+
+  return {
+    score: totalScore,
+    detail: `Certainty: ${certaintyScore}/40, Knowledge Boundary: ${boundaryScore}/40, Assumptions: ${assumptionScore}/20`,
+    issues
+  };
+}