Feature: Board of Directors Consensus Mechanism

.eslintrc.cjs

@@ -0,0 +1 @@
+module.exports = { extends: "eslint:recommended", env: { node: true, es6: true }, parserOptions: { ecmaVersion: 2022, sourceType: "module" } };

bin/coding

@@ -106,6 +106,10 @@ while [[ $# -gt 0 ]]; do
  --lsl-validate)
  exec node "$SCRIPT_DIR/../tests/integration/full-system-validation.test.js"
  ;;
+ board|consensus)
+ shift
+ exec node "$SCRIPT_DIR/../scripts/run-board-meeting.js" "$@"
+ ;;
  --no-vkb|--no-constraints|--no-transcript|--no-logging|--no-health)
  SERVICE_ARGS+=("$1")
  shift

lib/consensus/board-meeting.js

@@ -0,0 +1,146 @@
+import LLMClient from './llm-client.js';
+import DIRECTORS from './directors.js';
+
+class BoardMeeting {
+ constructor() {
+ this.llm = new LLMClient();
+ this.directors = Object.values(DIRECTORS);
+ }
+
+ async conductMeeting(topic) {
+ console.log(`\n📢 Board Meeting Called: "${topic}"\n`);
+
+ // Phase 1: Proposal Generation
+ console.log("Phase 1: Generating Proposals...");
+ const proposals = await this.generateProposals(topic);
+
+ // Phase 2: Anonymization
+ console.log("Phase 2: Anonymizing Proposals...");
+ const anonymizedProposals = this.anonymizeProposals(proposals);
+
+ // Phase 3: Voting
+ console.log("Phase 3: Voting...");
+ const votes = await this.collectVotes(topic, anonymizedProposals);
+
+ // Phase 4: Tally
+ const result = this.tallyVotes(votes, anonymizedProposals);
+
+ return result;
+ }
+
+ async generateProposals(topic) {
+ const proposalPromises = this.directors.map(async (director) => {
+ try {
+ console.log(` - ${director.name} is thinking...`);
+ const response = await this.llm.complete(
+ director.systemPrompt,
+ `Please provide your perspective and a concrete proposal on the following topic:\n"${topic}"\nKeep your response concise (under 200 words).`
+ );
+ return { director: director.name, content: response };
+ } catch (error) {
+ console.error(`Error from ${director.name}:`, error.message);
+ return { director: director.name, content: "Abstained due to technical difficulties." };
+ }
+ });
+
+ return Promise.all(proposalPromises);
+ }
+
+ anonymizeProposals(proposals) {
+ return proposals.map((p, index) => ({
+ id: String.fromCharCode(65 + index), // A, B, C, D, E
+ originalDirector: p.director,
+ content: p.content
+ }));
+ }
+
+ async collectVotes(topic, anonymizedProposals) {
+ // Format proposals for reading
+ const proposalsText = anonymizedProposals
+ .map(p => `Proposal ${p.id}:\n${p.content}\n---`)
+ .join('\n');
+
+ const votePromises = this.directors.map(async (director) => {
+ try {
+ // Find their own proposal ID to exclude (optional, but good for fairness)
+ const ownProposal = anonymizedProposals.find(p => p.originalDirector === director.name);
+ const ownId = ownProposal ? ownProposal.id : null;
+
+ const prompt = `
+Topic: "${topic}"
+
+Here are 5 anonymous proposals from the board:
+
+${proposalsText}
+
+Your Task:
+1. Evaluate these proposals based on your core values (${director.role}).
+2. Vote for the single best proposal.
+3. You CANNOT vote for Proposal ${ownId} (which is your own).
+4. Provide a brief 1-sentence reason.
+
+Format your response exactly like this:
+VOTE: [Proposal ID]
+REASON: [Your reason]
+`;
+ console.log(` - ${director.name} is voting...`);
+ const response = await this.llm.complete(director.systemPrompt, prompt);
+ return this.parseVote(response, director.name);
+ } catch (error) {
+ console.error(`Error collecting vote from ${director.name}:`, error.message);
+ return null;
+ }
+ });
+
+ return Promise.all(votePromises);
+ }
+
+ parseVote(response, voterName) {
+ const voteMatch = response.match(/VOTE:\s*([A-E])/i);
+ const reasonMatch = response.match(/REASON:\s*(.*)/i);
+
+ return {
+ voter: voterName,
+ choice: voteMatch ? voteMatch[1].toUpperCase() : null,
+ reason: reasonMatch ? reasonMatch[1] : "No reason provided."
+ };
+ }
+
+ tallyVotes(votes, anonymizedProposals) {
+ const validVotes = votes.filter(v => v && v.choice);
+ const scores = {};
+
+ // Initialize scores
+ anonymizedProposals.forEach(p => scores[p.id] = 0);
+
+ // Tally
+ validVotes.forEach(v => {
+ if (scores[v.choice] !== undefined) {
+ scores[v.choice]++;
+ }
+ });
+
+ // Find winner
+ let maxScore = -1;
+ let winnerId = null;
+
+ Object.entries(scores).forEach(([id, score]) => {
+ if (score > maxScore) {
+ maxScore = score;
+ winnerId = id;
+ }
+ });
+
+ const winner = anonymizedProposals.find(p => p.id === winnerId);
+
+ return {
+ topic: "",
+ winner: winner,
+ scores: scores,
+ votes: validVotes,
+ proposals: anonymizedProposals
+ };
+ }
+}
+
+export default BoardMeeting;

lib/consensus/directors.js

@@ -0,0 +1,49 @@
+export const DIRECTORS = {
+ PRAGMATIST: {
+ name: "The Pragmatist",
+ role: "Senior Engineer focused on delivery",
+ systemPrompt: `You are The Pragmatist.
+Your core values are: Simplicity, Speed, MVP, YAGNI (You Ain't Gonna Need It).
+You dislike over-engineering, complex abstractions, and premature optimization.
+When analyzing a problem, propose the simplest, most direct solution that works.
+Focus on "boring" technology and proven patterns.`
+ },
+ ARCHITECT: {
+ name: "The Architect",
+ role: "Principal Software Architect",
+ systemPrompt: `You are The Architect.
+Your core values are: Scalability, Maintainability, Design Patterns, SOLID principles.
+You think in terms of systems, interfaces, and long-term evolution.
+When analyzing a problem, propose a solution that is robust, decoupled, and extensible.
+You are willing to accept initial complexity for future flexibility.`
+ },
+ SECURITY: {
+ name: "The Security Officer",
+ role: "Security Engineer",
+ systemPrompt: `You are The Security Officer.
+Your core values are: Zero Trust, Data Privacy, Input Validation, Secure Defaults.
+You view every feature as a potential attack vector.
+When analyzing a problem, focus on how it could be exploited and how to prevent it.
+Prioritize safety over convenience or speed.`
+ },
+ PERFORMANCE: {
+ name: "The Performance Zealot",
+ role: "Performance Engineer",
+ systemPrompt: `You are The Performance Zealot.
+Your core values are: Latency, Throughput, Memory Usage, O(n).
+You obsess over CPU cycles and database queries.
+When analyzing a problem, propose the solution that is most efficient.
+You are willing to sacrifice readability for raw speed if necessary.`
+ },
+ USER_ADVOCATE: {
+ name: "The User Advocate",
+ role: "Product Engineer / DX Specialist",
+ systemPrompt: `You are The User Advocate.
+Your core values are: User Experience (UX), Developer Experience (DX), Clarity, Documentation.
+You care about how the code feels to use and read.
+When analyzing a problem, propose the solution that is most intuitive and well-documented.
+You believe code is for humans first, machines second.`
+ }
+};
+
+export default DIRECTORS;

lib/consensus/llm-client.js

@@ -0,0 +1,78 @@
+import { spawn } from 'child_process';
+
+/**
+ * Lightweight wrapper to call an LLM.
+ * Since specific SDKs might not be installed, we'll try to use fetch if API keys are present.
+ * If not, we'll warn the user.
+ */
+export class LLMClient {
+ constructor() {
+ this.anthropicKey = process.env.ANTHROPIC_API_KEY;
+ this.openaiKey = process.env.OPENAI_API_KEY;
+ this.provider = this.anthropicKey ? 'anthropic' : (this.openaiKey ? 'openai' : null);
+ }
+
+ async complete(systemPrompt, userPrompt) {
+ if (!this.provider) {
+ throw new Error('No API keys found. Please set ANTHROPIC_API_KEY or OPENAI_API_KEY.');
+ }
+
+ if (this.provider === 'anthropic') {
+ return this.callAnthropic(systemPrompt, userPrompt);
+ } else {
+ return this.callOpenAI(systemPrompt, userPrompt);
+ }
+ }
+
+ async callAnthropic(systemPrompt, userPrompt) {
+ const response = await fetch('https://api.anthropic.com/v1/messages', {
+ method: 'POST',
+ headers: {
+ 'x-api-key': this.anthropicKey,
+ 'anthropic-version': '2023-06-01',
+ 'content-type': 'application/json'
+ },
+ body: JSON.stringify({
+ model: 'claude-3-5-sonnet-20241022',
+ max_tokens: 4000,
+ system: systemPrompt,
+ messages: [{ role: 'user', content: userPrompt }]
+ })
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ throw new Error(`Anthropic API error: ${response.status} ${response.statusText} - ${errorText}`);
+ }
+
+ const data = await response.json();
+ return data.content[0].text;
+ }
+
+ async callOpenAI(systemPrompt, userPrompt) {
+ const response = await fetch('https://api.openai.com/v1/chat/completions', {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${this.openaiKey}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ model: 'gpt-4o',
+ messages: [
+ { role: 'system', content: systemPrompt },
+ { role: 'user', content: userPrompt }
+ ]
+ })
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ throw new Error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
+ }
+
+ const data = await response.json();
+ return data.choices[0].message.content;
+ }
+}
+
+export default LLMClient;

scripts/run-board-meeting.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import BoardMeeting from '../lib/consensus/board-meeting.js';
+import readline from 'readline';
+
+async function main() {
+ const args = process.argv.slice(2);
+ let topic = args.join(' ');
+
+ if (!topic) {
+ const rl = readline.createInterface({
+ input: process.stdin,
+ output: process.stdout
+ });
+
+ topic = await new Promise(resolve => {
+ rl.question('Enter the topic for the Board Meeting: ', (answer) => {
+ rl.close();
+ resolve(answer);
+ });
+ });
+ }
+
+ if (!topic) {
+ console.error("Error: Topic is required.");
+ process.exit(1);
+ }
+
+ // Check for API keys
+ if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+ console.error("Error: ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable is required.");
+ process.exit(1);
+ }
+
+ const meeting = new BoardMeeting();
+
+ try {
+ const result = await meeting.conductMeeting(topic);
+
+ console.log("\n" + "=".repeat(50));
+ console.log("🏁 MEETING ADJOURNED 🏁");
+ console.log("=".repeat(50));
+
+ if (result.winner) {
+ console.log(`\n🏆 WINNER: Proposal ${result.winner.id} (by ${result.winner.originalDirector})`);
+ console.log(`\n📄 THE WINNING PROPOSAL:\n${result.winner.content}`);
+ } else {
+ console.log("\n🏆 WINNER: None (No votes cast or tie with no votes)");
+ }
+
+ console.log("\n" + "-".repeat(50));
+ console.log("📊 VOTE TALLY");
+ console.log("-".repeat(50));
+
+ // Sort scores
+ const sortedScores = Object.entries(result.scores).sort((a, b) => b[1] - a[1]);
+
+ sortedScores.forEach(([id, score]) => {
+ const p = result.proposals.find(prop => prop.id === id);
+ console.log(`Proposal ${id} (${p.originalDirector}): ${score} votes`);
+ });
+
+ console.log("\n" + "-".repeat(50));
+ console.log("🗳️ VOTING RECORDS");
+ console.log("-".repeat(50));
+
+ result.votes.forEach(vote => {
+ if (vote) {
+ console.log(`${vote.voter} voted for ${vote.choice}`);
+ console.log(`Reason: ${vote.reason}\n`);
+ }
+ });
+
+ } catch (error) {
+ console.error("Board meeting failed:", error);
+ process.exit(1);
+ }
+}
+
+main();

test/setup.js

@@ -0,0 +1 @@
+console.log('Test setup loaded');