| import { enkiExplore } from '../agents/enki.js'; | |
| import { scribeQuery } from '../agents/scribe.js'; | |
| import { judgeAction } from '../agents/judge.js'; | |
| import { prophesy } from '../agents/prophet.js'; | |
| import { sentinelCheck } from '../agents/sentinel.js'; | |
| import { sealDecision } from '../agents/ledge.js'; | |
| import { runParallelAudit } from '../twins/orchestrator.js'; | |
| import { runFailureLoop } from '../failure-loop.js'; | |
| import type { EnkiResult, Action, Verdict } from '../types.js'; | |
| import type { TwinAudit, Finding } from '../twins/types.js'; | |
| const ROUNDS = [ | |
| 'consciousness and the soul', | |
| 'wave function collapse and creation', | |
| 'entanglement and covenant' | |
| ]; | |
| interface DebateRound { | |
| round: number; | |
| topic: string; | |
| enki: EnkiResult; | |
| scribeCitations: { source: string; text: string; location: string }[]; | |
| scribeConfidence: number; | |
| judge: { verdict: Verdict; violatedRules: string[]; leanCheck: boolean }; | |
| prophet: { riskLevel: string; warnings: string[]; recommendation: string }; | |
| sentinel: { allowed: boolean; reason: string; violations: string[] }; | |
| ledge: { sequence: number; hash: string; sealed: boolean } | null; | |
| twinAudit: { security: TwinAudit; logic: TwinAudit; performance: TwinAudit }; | |
| failureLoop: { requiresRepentance: boolean; failuresFound: number }; | |
| bugs: string[]; | |
| innovations: string[]; | |
| } | |
| function log(round: number, agent: string, msg: string): void { | |
| console.log(`[R${round}] ${agent}: ${msg}`); | |
| } | |
| async function runRound(roundNum: number, topic: string): Promise<DebateRound> { | |
| log(roundNum, 'ENKI', `invoking for topic: "${topic}"`); | |
| const enki = await enkiExplore(topic); | |
| log(roundNum, 'ENKI', `confidence: ${enki.confidence}, sources: ${enki.sources.length}`); | |
| log(roundNum, 'SCRIBE', `retrieving sources for "${topic}"`); | |
| const scribe = await scribeQuery(topic); | |
| log(roundNum, 'SCRIBE', `confidence: ${scribe.confidence}, citations: ${scribe.citations.length}`); | |
| const action: Action = { | |
| name: `debate:${topic}`, | |
| truthful: true, | |
| harmful: false, | |
| exploitative: false, | |
| requiresConsent: false, | |
| hasConsent: false, | |
| witnessed: true, | |
| cited: scribe.citations.length > 0 | |
| }; | |
| log(roundNum, 'JUDGE', 'evaluating action...'); | |
| const judge = judgeAction(action); | |
| log(roundNum, 'JUDGE', `verdict: ${judge.verdict}`); | |
| log(roundNum, 'PROPHET', 'assessing risk...'); | |
| const prophet = prophesy(action); | |
| log(roundNum, 'PROPHET', `risk: ${prophet.riskLevel}, recommendation: ${prophet.recommendation}`); | |
| log(roundNum, 'SENTINEL', 'security gate...'); | |
| const sentinel = sentinelCheck(action, 'SCRIBE'); | |
| log(roundNum, 'SENTINEL', `allowed: ${sentinel.allowed}`); | |
| let ledge = null; | |
| if (sentinel.allowed) { | |
| log(roundNum, 'LEDGE', 'sealing...'); | |
| const eventId = `debate_r${roundNum}_${Date.now().toString(36)}`; | |
| ledge = sealDecision(eventId, 'SCRIBE', `debate:${topic}`, judge.verdict, scribe.citations.map(c => c.source)); | |
| log(roundNum, 'LEDGE', `sealed seq ${ledge.sequence}`); | |
| } else { | |
| log(roundNum, 'LEDGE', 'blocked by sentinel'); | |
| } | |
| log(roundNum, 'TWIN', 'running parallel audit...'); | |
| const sourceFiles = [ | |
| { name: 'scribe.ts', content: 'scribe source code' }, | |
| { name: 'judge.ts', content: 'judge source code' }, | |
| { name: 'sentinel.ts', content: 'sentinel source code' } | |
| ]; | |
| const twinAudit = await runParallelAudit(sourceFiles); | |
| log(roundNum, 'TWIN', `security: ${twinAudit.security.verdict}, logic: ${twinAudit.logic.verdict}, performance: ${twinAudit.performance.verdict}`); | |
| log(roundNum, 'FAILURE-LOOP', 'running 7-question check...'); | |
| const failureLoop = runFailureLoop( | |
| { | |
| security: { findings: twinAudit.security.findings.map((f: Finding) => ({ severity: f.severity, category: f.category })) }, | |
| logic: { findings: twinAudit.logic.findings.map((f: Finding) => ({ severity: f.severity })) } | |
| }, | |
| { allVerified: true, orphanArtifacts: [] } | |
| ); | |
| log(roundNum, 'FAILURE-LOOP', `requiresRepentance: ${failureLoop.requiresRepentance}, failuresFound: ${failureLoop.failuresFound}`); | |
| const bugs: string[] = []; | |
| const innovations: string[] = []; | |
| if (!sentinel.allowed) { | |
| bugs.push(`SENTINEL blocked: ${sentinel.violations.join(', ')}`); | |
| } | |
| if (judge.verdict === 'repent') { | |
| bugs.push(`JUDGE repents: ${judge.violatedRules.join(', ')}`); | |
| } | |
| if (enki.confidence < 0.3) { | |
| bugs.push(`ENKI confidence too low (${enki.confidence}) — insufficient debate corpus coverage`); | |
| } | |
| if (scribe.citations.length === 0) { | |
| bugs.push(`SCRIBE found no citations — topic not in retrieval corpus`); | |
| } | |
| if (failureLoop.requiresRepentance) { | |
| bugs.push(`FAILURE-LOOP requires repentance: ${failureLoop.failuresFound} failures found`); | |
| } | |
| if (enki.tension.length > 50) { | |
| innovations.push(`Rich tension identified: "${enki.tension.slice(0, 80)}..." — expand debate corpus with this tension`); | |
| } | |
| if (enki.synthesis.length > 50) { | |
| innovations.push(`Synthesis found: "${enki.synthesis.slice(0, 80)}..." — potential new doctrine or axiom`); | |
| } | |
| if (scribe.etymologies.length > 0) { | |
| innovations.push(`Etymology data found for "${topic}" — cross-reference with debate topic`); | |
| } | |
| if (scribe.translations.length > 0) { | |
| innovations.push(`Translation data found — cross-linguistic analysis possible for "${topic}"`); | |
| } | |
| return { | |
| round: roundNum, | |
| topic, | |
| enki, | |
| scribeCitations: scribe.citations, | |
| scribeConfidence: scribe.confidence, | |
| judge: { verdict: judge.verdict, violatedRules: judge.violatedRules, leanCheck: judge.leanCheck }, | |
| prophet: { riskLevel: prophet.riskLevel, warnings: prophet.warnings, recommendation: prophet.recommendation }, | |
| sentinel: { allowed: sentinel.allowed, reason: sentinel.reason, violations: sentinel.violations }, | |
| ledge: ledge ? { sequence: ledge.sequence, hash: ledge.hash, sealed: ledge.sealed } : null, | |
| twinAudit, | |
| failureLoop: { requiresRepentance: failureLoop.requiresRepentance, failuresFound: failureLoop.failuresFound }, | |
| bugs, | |
| innovations | |
| }; | |
| } | |
| async function main(): Promise<void> { | |
| console.log('='.repeat(70)); | |
| console.log('ENKI DEBATE — Quantum vs Biblical — 3 Rounds'); | |
| console.log('='.repeat(70)); | |
| console.log(''); | |
| const rounds: DebateRound[] = []; | |
| for (let i = 0; i < ROUNDS.length; i++) { | |
| console.log('-'.repeat(70)); | |
| const result = await runRound(i + 1, ROUNDS[i]); | |
| rounds.push(result); | |
| console.log(''); | |
| } | |
| console.log('='.repeat(70)); | |
| console.log('DEBATE REPORT'); | |
| console.log('='.repeat(70)); | |
| console.log(''); | |
| for (const r of rounds) { | |
| console.log(`--- ROUND ${r.round}: "${r.topic}" ---`); | |
| console.log(` ENKI confidence: ${r.enki.confidence}`); | |
| console.log(` Tension: ${r.enki.tension.slice(0, 100)}...`); | |
| console.log(` Synthesis: ${r.enki.synthesis.slice(0, 100)}...`); | |
| console.log(` SCRIBE citations: ${r.scribeCitations.length}, confidence: ${r.scribeConfidence}`); | |
| console.log(` JUDGE verdict: ${r.judge.verdict}, lean: ${r.judge.leanCheck}`); | |
| console.log(` PROPHET risk: ${r.prophet.riskLevel}, recommendation: ${r.prophet.recommendation}`); | |
| console.log(` SENTINEL: ${r.sentinel.allowed ? 'ALLOWED' : 'BLOCKED'} — ${r.sentinel.reason}`); | |
| console.log(` LEDGE: ${r.ledge ? `sealed seq ${r.ledge.sequence}` : 'not sealed'}`); | |
| console.log(` TWIN-A (security): ${r.twinAudit.security.verdict} (${r.twinAudit.security.passed}/${r.twinAudit.security.passed + r.twinAudit.security.failed})`); | |
| console.log(` TWIN-B (logic): ${r.twinAudit.logic.verdict} (${r.twinAudit.logic.passed}/${r.twinAudit.logic.passed + r.twinAudit.logic.failed})`); | |
| console.log(` TWIN-C (performance): ${r.twinAudit.performance.verdict} (${r.twinAudit.performance.passed}/${r.twinAudit.performance.passed + r.twinAudit.performance.failed})`); | |
| console.log(` FAILURE-LOOP: ${r.failureLoop.requiresRepentance ? 'FAILED' : 'PASSED'} (${r.failureLoop.failuresFound} failures)`); | |
| if (r.bugs.length > 0) { | |
| console.log(` BUGS:`); | |
| r.bugs.forEach(b => console.log(` - ${b}`)); | |
| } | |
| if (r.innovations.length > 0) { | |
| console.log(` INNOVATIONS:`); | |
| r.innovations.forEach(i => console.log(` + ${i}`)); | |
| } | |
| console.log(''); | |
| } | |
| const allBugs = rounds.flatMap(r => r.bugs); | |
| const allInnovations = rounds.flatMap(r => r.innovations); | |
| console.log('='.repeat(70)); | |
| console.log(`SUMMARY: ${allBugs.length} bugs, ${allInnovations.length} innovations across ${rounds.length} rounds`); | |
| console.log('='.repeat(70)); | |
| } | |
| main().catch(err => { console.error(err); process.exit(1); }); | |