mcp-council-server 4.0.0

package/src/tools.js

@@ -0,0 +1,556 @@
+import { z } from 'zod';
+import { CONFIG } from './config.js';
+import { createSession, getSession, updateSessionStatus, updateSessionPhase } from './memory/session.js';
+import { getActivePhase, getAllPhases, savePhaseOutput, validatePhaseTransition, unlockNextPhase } from './memory/phase.js';
+import { saveDecision } from './memory/decision.js';
+import { composeRecallContext } from './memory/recall.js';
+import { parseTaskStructure, extractDeliverables, extractUnresolved } from './analysis/parser.js';
+import { assessComplexity, generatePipeline, getPhaseInstructions } from './prinsip/adaptive.js';
+import { validateCertainty, extractKnowledgeBoundary, createTransparencyLogEntry } from './prinsip/transparency.js';
+import { getPersona, validateAuthority, buildHandshake } from './prinsip/agentic.js';
+import { detectContradictions } from './verify/contradiction.js';
+import { checkGrounding } from './verify/grounding.js';
+import { calculatePhaseScore } from './score/index.js';
+import { scoreCompleteness } from './score/completeness.js';
+import { scoreConsistency } from './score/consistency.js';
+import { scoreTransparency } from './score/transparency.js';
+import { scoreAgentic } from './score/agentic.js';
+import { insert } from './db/json-store.js';
+
+function sanitize(str) {
+  if (typeof str !== 'string') return '';
+  return str.replace(/\0/g, '').normalize('NFKC').trim();
+}
+
+function buildError(message) {
+  return { content: [{ type: 'text', text: JSON.stringify({ error: message }) }], isError: true };
+}
+
+function buildResponse(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+const InitSchema = z.object({
+  task: z.string().min(10).max(CONFIG.MAX_TASK_LENGTH),
+  context: z.string().max(CONFIG.MAX_CONTEXT_LENGTH).optional().default(''),
+  title: z.string().max(200).optional().default('')
+});
+
+const SaveSchema = z.object({
+  sessionId: z.string().uuid(),
+  phase: z.enum(['decompile', 'design', 'critique', 'synthesis', 'verify']),
+  output: z.object({
+    summary: z.string().min(1).max(20000),
+    decisions: z.array(z.object({
+      description: z.string(),
+      rationale: z.string().optional().default(''),
+      alternatives: z.array(z.string()).optional().default([]),
+      rejectedReasons: z.record(z.string()).optional().default({})
+    })).optional().default([]),
+    constraints: z.array(z.string()).optional().default([]),
+    confidence: z.number().min(0).max(1),
+    claims: z.array(z.object({
+      text: z.string(),
+      certainty: z.enum(['confirmed', 'likely', 'uncertain', 'unknown', 'assumption']).optional().default('unknown'),
+      source: z.string().optional().default('assumption')
+    })).optional().default([]),
+    knowledgeBoundary: z.object({
+      whatIKnow: z.array(z.string()).optional().default([]),
+      whatIAssume: z.array(z.string()).optional().default([]),
+      whatIDontKnow: z.array(z.string()).optional().default([]),
+      whatNeedsVerification: z.array(z.string()).optional().default([])
+    }).optional().default({}),
+    approaches: z.array(z.any()).optional(),
+    justification: z.string().optional(),
+    tradeoffs: z.array(z.any()).optional(),
+    recommended: z.string().optional(),
+    vulnerabilities: z.array(z.any()).optional(),
+    riskLevel: z.string().optional(),
+    mitigation: z.array(z.any()).optional(),
+    implementation: z.array(z.any()).optional(),
+    testing: z.array(z.any()).optional(),
+    warnings: z.array(z.string()).optional().default([]),
+    checks: z.array(z.any()).optional(),
+    passedCount: z.number().optional(),
+    failedCount: z.number().optional(),
+    finalConfidence: z.number().optional(),
+    criticalQuestions: z.array(z.string()).optional().default([])
+  })
+});
+
+const RecallSchema = z.object({
+  sessionId: z.string().uuid(),
+  focus: z.array(z.enum(['decompile', 'design', 'critique', 'synthesis', 'verify'])).optional(),
+  format: z.enum(['full', 'summary', 'decisions']).optional().default('full')
+});
+
+const VerifySchema = z.object({
+  sessionId: z.string().uuid(),
+  claims: z.array(z.object({
+    text: z.string(),
+    source: z.string().optional().default('assumption'),
+    type: z.string().optional().default('')
+  })),
+  mode: z.enum(['contradiction', 'grounding', 'all']).optional().default('all')
+});
+
+const ContinueSchema = z.object({
+  sessionId: z.string().uuid()
+});
+
+const ScoreSchema = z.object({
+  sessionId: z.string().uuid()
+});
+
+export function registerCouncilTools(server) {
+  // ─── Tool 1: council_init ───────────────────────────────────────
+  server.tool(
+    'council_init',
+    'Memulai sesi reasoning council. Panggil pertama kali saat menerima prompt kompleks dari user. ' +
+      'Mengembalikan adaptive pipeline, persona, phase plan, dan memory slots. ' +
+      'Pipeline menyesuaikan kompleksitas task (light/standard/full).',
+    {
+      task: z.string().min(10).max(CONFIG.MAX_TASK_LENGTH).describe('Prompt kompleks dari user'),
+      context: z.string().max(CONFIG.MAX_CONTEXT_LENGTH).optional().describe('Konteks tambahan'),
+      title: z.string().max(200).optional().describe('Nama sesi untuk identifikasi')
+    },
+    async ({ task, context, title }) => {
+      try {
+        const cleanTask = sanitize(task);
+        const cleanContext = sanitize(context || '');
+
+        const structure = parseTaskStructure(cleanTask);
+        const complexity = assessComplexity(cleanTask, structure);
+        const pipeline = generatePipeline(complexity);
+        const sessionId = createSession(cleanTask, cleanContext, title, complexity, pipeline);
+        const activePhase = getActivePhase(sessionId);
+        const persona = getPersona(activePhase.name);
+
+        return buildResponse({
+          type: 'council_init',
+          sessionId,
+          adaptation: {
+            complexity,
+            pipeline: pipeline.map((p, i) => ({ ...p, order: i + 1 })),
+            adaptiveReason: `Complexity score ${complexity.normalized}/100 (${complexity.level}). Pipeline: ${complexity.pipelineDepth}.`
+          },
+          personas: { current: { name: persona.name, identity: persona.identity, authority: persona.authority, notAuthority: persona.notAuthority } },
+          phase: activePhase.name,
+          phasePlan: pipeline.map((p, i) => ({
+            name: p.name, persona: p.persona, order: i + 1, status: i === 0 ? 'active' : 'locked'
+          })),
+          instructions: getPhaseInstructions(activePhase.name, activePhase.depth),
+          memorySlots: {
+            originalTask: cleanTask,
+            decompositions: [],
+            decisions: [],
+            constraints: [],
+            criticalQuestions: []
+          },
+          transparencyLog: { entries: [], count: 0 }
+        });
+      } catch (err) {
+        return buildError(`Gagal inisialisasi: ${err.message}`);
+      }
+    }
+  );
+
+  // ─── Tool 2: council_save ─────────────────────────────────────────
+  server.tool(
+    'council_save',
+    'Simpan hasil fase ke memory. Fase harus sesuai urutan (tidak bisa skip). ' +
+      'Setelah save: server menghitung scoring, deteksi kontradiksi, validasi authority, ' +
+      'dan menyusun handoff ke fase berikutnya. Jika score < 70, AI disarankan refine fase ini.',
+    {
+      sessionId: z.string().uuid().describe('ID sesi dari council_init'),
+      phase: z.enum(['decompile', 'design', 'critique', 'synthesis', 'verify']).describe('Nama fase yang akan disimpan'),
+      output: z.any().describe('Output fase — object dengan summary, decisions, claims, dll')
+    },
+    async ({ sessionId, phase, output }) => {
+
+      try {
+        // Validasi session
+        const session = getSession(sessionId);
+        if (!session) return buildError('Session tidak ditemukan. Gunakan council_init untuk memulai sesi baru.');
+
+        // Validasi phase transition
+        const transition = validatePhaseTransition(sessionId, session.current_phase, phase);
+        if (!transition.valid) return buildError(transition.error);
+
+        // Authority validation
+        const persona = getPersona(phase);
+        const authorityWarnings = validateAuthority(phase, output);
+
+        // Get previous phases for scoring
+        const allPhases = getAllPhases(sessionId);
+        const previousPhases = allPhases.filter(p => p.status === 'done');
+
+        // Scoring
+        const score = calculatePhaseScore(phase, output, previousPhases);
+
+        // Transparency validation
+        const certaintyResult = validateCertainty(output.claims || []);
+        const kb = extractKnowledgeBoundary(output);
+
+        // Contradiction detection
+        const conflicts = detectContradictions(output, previousPhases);
+
+        // Save to DB
+        savePhaseOutput(sessionId, phase, output, output.confidence, kb, certaintyResult.stats, authorityWarnings);
+
+        // Save decisions
+        if (output.decisions) {
+          for (const d of output.decisions) {
+            saveDecision(sessionId, phase, d.description, d.rationale, d.alternatives, d.rejectedReasons);
+          }
+        }
+
+        // Save claims to store
+        if (output.claims) {
+          for (const c of output.claims) {
+            insert('claims', {
+              id: CONFIG.uuidv4(),
+              session_id: sessionId,
+              phase_name: phase,
+              text: c.text,
+              certainty: c.certainty || 'unknown',
+              source: c.source || 'assumption',
+              status: 'unverified',
+              created_at: new Date().toISOString()
+            });
+          }
+        }
+
+        // Transparency log for issues
+        if (!certaintyResult.valid) {
+          createTransparencyLogEntry(sessionId, phase, 'uncertainty',
+            `${certaintyResult.unlabeled.length} claims tanpa certainty`, certaintyResult.unlabeled, 'unknown');
+        }
+        if (authorityWarnings.length > 0) {
+          createTransparencyLogEntry(sessionId, phase, 'boundary',
+            `${authorityWarnings.length} authority violations`, authorityWarnings, 'unknown');
+        }
+
+        // Handoff
+        const nextPhase = unlockNextPhase(sessionId, phase);
+        if (nextPhase) {
+          updateSessionPhase(sessionId, nextPhase.name);
+        } else {
+          updateSessionPhase(sessionId, 'done');
+          updateSessionStatus(sessionId, 'done');
+        }
+
+        const deliverables = extractDeliverables(output);
+        const unresolved = extractUnresolved(output);
+        const handshake = buildHandshake(phase, nextPhase?.name || 'done', deliverables, authorityWarnings, unresolved, conflicts);
+
+        // Context for next phase
+        let contextForNext = null;
+        if (nextPhase && score.canProceed) {
+          const nextPersona = getPersona(nextPhase.name);
+          contextForNext = {
+            currentPersona: {
+              name: nextPersona.name,
+              identity: nextPersona.identity,
+              authority: nextPersona.authority,
+              notAuthority: nextPersona.notAuthority
+            },
+            originalTask: session.task,
+            previousResults: allPhases.filter(p => p.status === 'done').map(p => ({
+              phase: p.name,
+              summary: p.output?.summary || '',
+              confidence: p.confidence
+            })),
+            phaseInstructions: getPhaseInstructions(nextPhase.name, nextPhase.depth)
+          };
+        }
+
+        return buildResponse({
+          type: 'council_save',
+          status: 'saved',
+          phase,
+          scoring: {
+            finalScore: score.finalScore,
+            verdict: score.verdict,
+            dimensions: score.dimensions,
+            suggestions: score.suggestions
+          },
+          canProceed: score.canProceed,
+          handoff: handshake,
+          nextPhase: nextPhase?.name || null,
+          phasePlan: allPhases.map(p => ({
+            name: p.name,
+            status: p.status === phase ? 'done' : p.name === nextPhase?.name ? 'active' : p.status === 'done' ? 'done' : 'locked'
+          })),
+          contextForNext,
+          sessionComplete: !nextPhase
+        });
+      } catch (err) {
+        return buildError(`Gagal menyimpan fase: ${err.message}`);
+      }
+    }
+  );
+
+  // ─── Tool 3: council_recall ───────────────────────────────────────
+  server.tool(
+    'council_recall',
+    'Ambil memory kapan saja. Berguna saat AI lupa konteks, mau review keputusan, ' +
+      'atau resume session. Tersedia format: full (default), summary, atau decisions-only.',
+    {
+      sessionId: z.string().uuid().describe('ID sesi'),
+      focus: z.array(z.enum(['decompile', 'design', 'critique', 'synthesis', 'verify'])).optional()
+        .describe('Fase spesifik yang ingin dilihat'),
+      format: z.enum(['full', 'summary', 'decisions']).optional().default('full')
+        .describe('Format output: full (default), summary, atau decisions-only')
+    },
+    async ({ sessionId, focus, format }) => {
+      try {
+        const context = composeRecallContext(sessionId, focus, format);
+        if (!context) return buildError('Session tidak ditemukan.');
+        return buildResponse({ type: 'council_recall', ...context });
+      } catch (err) {
+        return buildError(`Gagal recall: ${err.message}`);
+      }
+    }
+  );
+
+  // ─── Tool 4: council_verify ───────────────────────────────────────
+  server.tool(
+    'council_verify',
+    'Verifikasi klaim terhadap memory sesi. Deteksi kontradiksi numerik, polaritas, ' +
+      'dan grounding source. Mode: contradiction, grounding, atau all (default).',
+    {
+      sessionId: z.string().uuid().describe('ID sesi'),
+      claims: z.any().describe('Daftar klaim yang akan diverifikasi — array of {text, source?, type?}'),
+      mode: z.enum(['contradiction', 'grounding', 'all']).optional().default('all')
+        .describe('Mode verifikasi')
+    },
+    async ({ sessionId, claims, mode }) => {
+      try {
+        const session = getSession(sessionId);
+        if (!session) return buildError('Session tidak ditemukan.');
+
+        const allPhases = getAllPhases(sessionId);
+        const completedPhases = allPhases.filter(p => p.status === 'done');
+
+        const results = [];
+        let contradictionResults = [];
+        let groundingResults = null;
+
+        if (mode === 'contradiction' || mode === 'all') {
+          const claimsObj = { claims };
+          contradictionResults = detectContradictions(claimsObj, completedPhases);
+        }
+
+        if (mode === 'grounding' || mode === 'all') {
+          groundingResults = checkGrounding(claims);
+        }
+
+        let total = 0, passed = 0, warning = 0, contradicted = 0;
+
+        if (contradictionResults.length > 0) {
+          contradicted = contradictionResults.length;
+        }
+
+        if (groundingResults) {
+          passed = groundingResults.verified;
+          warning = groundingResults.unverified;
+          total = groundingResults.total;
+        }
+
+        return buildResponse({
+          type: 'council_verify',
+          results: {
+            contradictions: contradictionResults,
+            grounding: groundingResults
+          },
+          summary: {
+            total: Math.max(total, contradictionResults.length),
+            passed,
+            warning,
+            contradicted
+          }
+        });
+      } catch (err) {
+        return buildError(`Gagal verifikasi: ${err.message}`);
+      }
+    }
+  );
+
+  // ─── Tool 5: council_continue ─────────────────────────────────────
+  server.tool(
+    'council_continue',
+    'Resume session yang terhenti (karena restart atau interupsi). ' +
+      'Mengembalikan full context + fase terakhir yang aktif + instruksi resume.',
+    {
+      sessionId: z.string().uuid().describe('ID sesi yang akan dilanjutkan')
+    },
+    async ({ sessionId }) => {
+      try {
+        const session = getSession(sessionId);
+        if (!session) return buildError('Session tidak ditemukan.');
+
+        if (session.status === 'done') {
+          return buildError('Session sudah selesai. Gunakan council_recall untuk review.');
+        }
+
+        const activePhase = getActivePhase(sessionId);
+        if (!activePhase) return buildError('Tidak ada fase aktif. Session mungkin sudah selesai.');
+
+        const allPhases = getAllPhases(sessionId);
+        const lastDone = allPhases.filter(p => p.status === 'done').pop();
+        const persona = getPersona(activePhase.name);
+        const context = composeRecallContext(sessionId);
+
+        return buildResponse({
+          type: 'council_continue',
+          session: {
+            id: session.id,
+            task: session.task,
+            status: session.status,
+            currentPhase: session.current_phase,
+            progress: `${allPhases.filter(p => p.status === 'done').length}/${allPhases.length}`
+          },
+          currentPhase: {
+            name: activePhase.name,
+            persona: persona.name,
+            personaIdentity: persona.identity,
+            personaAuthority: persona.authority,
+            personaNotAuthority: persona.notAuthority,
+            instructions: getPhaseInstructions(activePhase.name, activePhase.depth)
+          },
+          lastCompletedPhase: lastDone ? { name: lastDone.name, summary: lastDone.output?.summary || '' } : null,
+          context,
+          resumeInstructions: `Lanjutkan dari fase ${activePhase.name} sebagai ${persona.name}. ${getPhaseInstructions(activePhase.name, activePhase.depth)}`
+        });
+      } catch (err) {
+        return buildError(`Gagal melanjutkan session: ${err.message}`);
+      }
+    }
+  );
+
+  // ─── Tool 6: council_score ────────────────────────────────────────
+  server.tool(
+    'council_score',
+    'Nilai kualitas seluruh sesi council. Menganalisis completeness, consistency, ' +
+      'transparency, dan agentic alignment dari SEMUA fase. Memberi overall score + rekomendasi.',
+    {
+      sessionId: z.string().uuid().describe('ID sesi yang akan dinilai')
+    },
+    async ({ sessionId }) => {
+      try {
+        const session = getSession(sessionId);
+        if (!session) return buildError('Session tidak ditemukan.');
+
+        const allPhases = getAllPhases(sessionId);
+        const completedPhases = allPhases.filter(p => p.status === 'done');
+
+        if (completedPhases.length === 0) {
+          return buildError('Belum ada fase yang selesai. Selesaikan minimal 1 fase terlebih dahulu.');
+        }
+
+        const perPhase = [];
+        let totalQuality = 0;
+        let totalTransparency = 0;
+        let totalAgentic = 0;
+        let totalAdaptability = 0;
+
+        for (let i = 0; i < completedPhases.length; i++) {
+          const phase = completedPhases[i];
+          const prevPhases = completedPhases.slice(0, i);
+          const persona = getPersona(phase.name);
+          const output = phase.output || {};
+
+          const compScore = scoreCompleteness(phase.name, output);
+          const consScore = scoreConsistency(phase.name, output, prevPhases);
+          const transScore = scoreTransparency(phase.name, output);
+          const agScore = scoreAgentic(phase.name, output, persona);
+
+          const phaseFinal = Math.round(
+            compScore.score * 0.25 + consScore.score * 0.25 +
+            (output.decisions?.length > 0 ? 80 : 0) * 0.15 +
+            transScore.score * 0.15 + agScore.score * 0.10 + 100 * 0.10
+          );
+
+          totalQuality += phaseFinal;
+          totalTransparency += transScore.score;
+          totalAgentic += agScore.score;
+
+          perPhase.push({
+            phase: phase.name,
+            persona: persona.name,
+            finalScore: phaseFinal,
+            verdict: phaseFinal >= 90 ? 'excellent' : phaseFinal >= 70 ? 'good' : phaseFinal >= 50 ? 'needs_improvement' : 'insufficient',
+            dimensions: {
+              completeness: compScore,
+              consistency: { score: consScore.score, contradictions: consScore.contradictions },
+              transparency: transScore,
+              agentic: agScore
+            }
+          });
+        }
+
+        // Cross-phase contradictions
+        const crossPhaseIssues = [];
+        for (let i = 1; i < completedPhases.length; i++) {
+          const curr = completedPhases[i];
+          const prevs = completedPhases.slice(0, i);
+          if (curr.output) {
+            const contradictions = detectContradictions(curr.output, prevs);
+            if (contradictions.length > 0) {
+              crossPhaseIssues.push({
+                phase: curr.name,
+                contradictions: contradictions.slice(0, 5)
+              });
+            }
+          }
+        }
+
+        const avgQuality = Math.round(totalQuality / completedPhases.length);
+        const avgTransparency = Math.round(totalTransparency / completedPhases.length);
+        const avgAgentic = Math.round(totalAgentic / completedPhases.length);
+        const adaptabilityScore = session.adaptation_plan?.length > 0 ? 85 : 70;
+
+        const overall = Math.round(avgQuality * 0.4 + adaptabilityScore * 0.2 + avgTransparency * 0.2 + avgAgentic * 0.2);
+        const finalVerdict = overall >= 90 ? 'excellent' : overall >= 70 ? 'good' : overall >= 50 ? 'needs_improvement' : 'insufficient';
+
+        // Suggestions
+        const suggestions = [];
+        if (crossPhaseIssues.length > 0) {
+          suggestions.push(`Resolve ${crossPhaseIssues.length} cross-phase contradiction(s)`);
+        }
+        const lowScorePhases = perPhase.filter(p => p.finalScore < 70);
+        if (lowScorePhases.length > 0) {
+          suggestions.push(`Perbaiki fase: ${lowScorePhases.map(p => `${p.phase}(${p.finalScore})`).join(', ')}`);
+        }
+        if (avgTransparency < 70) {
+          suggestions.push('Tingkatkan transparansi: tambahkan certainty level dan knowledge boundary');
+        }
+        if (avgAgentic < 70) {
+          suggestions.push('Tingkatkan agentic alignment: ikuti batasan authority persona');
+        }
+        if (suggestions.length === 0) {
+          suggestions.push('Semua fase berkualitas baik. Tidak ada rekomendasi perbaikan.');
+        }
+
+        return buildResponse({
+          type: 'council_score',
+          sessionId,
+          overall: {
+            finalScore: overall,
+            verdict: finalVerdict,
+            qualityScore: avgQuality,
+            adaptabilityScore,
+            transparencyScore: avgTransparency,
+            agenticScore: avgAgentic
+          },
+          perPhase,
+          crossPhaseIssues,
+          improvementSuggestions: suggestions
+        });
+      } catch (err) {
+        return buildError(`Gagal menghitung score: ${err.message}`);
+      }
+    }
+  );
+}

package/src/verify/contradiction.js

@@ -0,0 +1,125 @@
+const POLARITY_PAIRS = [
+  ['increase', 'decrease'], ['use', 'avoid'], ['sync', 'async'],
+  ['monolith', 'microservice'], ['sql', 'nosql'],
+  ['paid', 'free'], ['fast', 'slow'],
+  ['secure', 'insecure'], ['include', 'exclude'],
+  ['start', 'stop'], ['enable', 'disable'],
+  ['accept', 'reject'], ['allow', 'deny'],
+  ['optimistic', 'pessimistic'], ['vertical', 'horizontal'],
+  ['centralized', 'decentralized'], ['synchronous', 'asynchronous'],
+  ['blocking', 'non-blocking'], ['stateful', 'stateless']
+];
+
+export function detectContradictions(newOutput, previousPhases) {
+  if (!previousPhases || previousPhases.length === 0) {
+    return [];
+  }
+
+  const contradictions = [];
+  const newText = JSON.stringify(newOutput).toLowerCase();
+
+  // 1. Numerical contradiction detection
+  const numberPattern = /\b(\d+\.?\d*)\s*(ms|s|gb|mb|kb|%|usd|rb|rps|qps|tps|menit|jam|hari|gbps|mbps)?\b/g;
+
+  const currentNumbers = [];
+  let match;
+  while ((match = numberPattern.exec(newText)) !== null) {
+    currentNumbers.push({ value: parseFloat(match[1]), unit: (match[2] || '').toLowerCase(), raw: match[0] });
+  }
+
+  for (const prev of previousPhases) {
+    if (!prev.output) continue;
+    const prevText = JSON.stringify(prev.output).toLowerCase();
+
+    const prevNumbers = [];
+    while ((match = numberPattern.exec(prevText)) !== null) {
+      prevNumbers.push({ value: parseFloat(match[1]), unit: (match[2] || '').toLowerCase(), raw: match[0] });
+    }
+
+    for (const curr of currentNumbers) {
+      if (isNaN(curr.value) || curr.value < 1) continue;
+
+      for (const prevN of prevNumbers) {
+        if (isNaN(prevN.value) || prevN.value < 1) continue;
+        if (curr.unit !== prevN.unit) continue;
+        if (!curr.unit || !prevN.unit) continue; // require explicit units
+
+        const deviation = Math.abs(curr.value - prevN.value) / Math.max(Math.abs(prevN.value), 0.001);
+        if (deviation > 0.2) {
+          const key = `${curr.raw}-vs-${prevN.raw}-${prev.name}`;
+          if (!contradictions.some(c => c.key === key)) {
+            contradictions.push({
+              key,
+              type: 'numerical',
+              detail: `Angka "${curr.raw}" (fase saat ini) vs "${prevN.raw}" (${prev.name}) — deviasi ${Math.round(deviation * 100)}%`,
+              between: [prev.name, 'current']
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // 2. Polarity contradiction detection
+  for (const [pos, neg] of POLARITY_PAIRS) {
+    const currentHasPos = newText.includes(pos);
+    const currentHasNeg = newText.includes(neg);
+
+    for (const prev of previousPhases) {
+      if (!prev.output) continue;
+      const prevText = JSON.stringify(prev.output).toLowerCase();
+      const prevHasPos = prevText.includes(pos);
+      const prevHasNeg = prevText.includes(neg);
+
+      if (currentHasPos && prevHasNeg) {
+        const key = `polarity-${pos}-${neg}-${prev.name}`;
+        if (!contradictions.some(c => c.key === key)) {
+          contradictions.push({
+            key,
+            type: 'polarity',
+            detail: `Fase ini bilang "${pos}" tapi ${prev.name} bilang "${neg}"`,
+            between: [prev.name, 'current']
+          });
+        }
+      }
+
+      if (currentHasNeg && prevHasPos) {
+        const key = `polarity-${neg}-${pos}-${prev.name}`;
+        if (!contradictions.some(c => c.key === key)) {
+          contradictions.push({
+            key,
+            type: 'polarity',
+            detail: `Fase ini bilang "${neg}" tapi ${prev.name} bilang "${pos}"`,
+            between: [prev.name, 'current']
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Constraint compliance check (soft warning)
+  for (const prev of previousPhases) {
+    if (!prev.output?.constraints) continue;
+    for (const constraint of prev.output.constraints) {
+      const keywords = String(constraint).toLowerCase().split(/[\s_]+/).filter(k => k.length > 3);
+      const found = keywords.some(k => newText.includes(k));
+      if (!found && keywords.length > 0) {
+        contradictions.push({
+          type: 'constraint_not_referenced',
+          detail: `Constraint "${constraint}" dari fase ${prev.name} tidak direferensi di fase ini`,
+          between: [prev.name, 'current'],
+          severity: 'warning'
+        });
+        break;
+      }
+    }
+  }
+
+  // Remove duplicates and clean up
+  return contradictions.map(c => ({
+    type: c.type,
+    detail: c.detail,
+    between: c.between,
+    severity: c.severity || 'contradiction'
+  }));
+}