@sebastientang/llm-council 0.2.0

package/dist/cli.js

@@ -0,0 +1,1151 @@
+// src/cli.ts
+import { parseArgs } from "util";
+import { readFileSync } from "fs";
+
+// src/engine.ts
+import mitt from "mitt";
+
+// src/types.ts
+import { z } from "zod";
+var ParticipantSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  systemPrompt: z.string(),
+  temperature: z.number().min(0).max(2).optional()
+});
+var SynthesisSchema = z.object({
+  recommendation: z.string(),
+  confidence: z.number().min(0).max(100),
+  reasoning: z.string(),
+  risks: z.array(z.string()),
+  dissent: z.array(z.string()),
+  validationGates: z.array(z.string()),
+  assumptions: z.array(z.string()),
+  raw: z.string()
+});
+var DeliberationMessageSchema = z.object({
+  participantId: z.string(),
+  participantName: z.string(),
+  round: z.number(),
+  content: z.string(),
+  timestamp: z.date(),
+  tokenCount: z.object({ input: z.number(), output: z.number() })
+});
+var DeliberationConfigSchema = z.object({
+  topic: z.string().min(1),
+  options: z.array(z.string()).optional(),
+  context: z.string().optional(),
+  preferredOption: z.string().optional(),
+  participants: z.array(ParticipantSchema).min(2),
+  rounds: z.number().min(1).max(5).default(2),
+  tokenBudget: z.object({
+    perResponse: z.number().positive().optional(),
+    total: z.number().positive().optional()
+  }).optional()
+});
+var DeliberationMetadataSchema = z.object({
+  totalTokens: z.object({ input: z.number(), output: z.number() }),
+  durationMs: z.number(),
+  modelBreakdown: z.record(
+    z.string(),
+    z.object({ input: z.number(), output: z.number() })
+  )
+});
+
+// src/engine.ts
+var Council = class {
+  providers;
+  protocol;
+  synthesizer;
+  synthesisProvider;
+  emitter = mitt();
+  constructor(options) {
+    this.providers = options.providers;
+    this.protocol = options.protocol;
+    this.synthesizer = options.synthesizer;
+    this.synthesisProvider = options.synthesisProvider;
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  async deliberate(rawConfig) {
+    try {
+      const config = DeliberationConfigSchema.parse(rawConfig);
+      const startTime = Date.now();
+      const allMessages = [];
+      const tokenTracker = {};
+      const roundCount = this.protocol.getRoundCount();
+      const rounds = Math.min(config.rounds, roundCount);
+      for (let round = 1; round <= rounds; round++) {
+        const prompts = this.protocol.buildPrompts(config, allMessages, round);
+        this.emitter.emit("round:start", {
+          round,
+          participantCount: prompts.length
+        });
+        const roundMessages = await Promise.all(
+          prompts.map(async (prompt) => {
+            const provider2 = this.providers.get(prompt.provider);
+            if (!provider2) {
+              throw new Error(
+                `Provider '${prompt.provider}' not found. Available: ${[...this.providers.keys()].join(", ")}`
+              );
+            }
+            const response = await provider2.complete({
+              model: prompt.model,
+              systemPrompt: prompt.systemPrompt,
+              messages: [{ role: "user", content: prompt.userMessage }],
+              temperature: prompt.temperature,
+              maxTokens: prompt.maxTokens
+            });
+            const participant = config.participants.find(
+              (p) => p.id === prompt.participantId
+            );
+            const message = {
+              participantId: prompt.participantId,
+              participantName: participant?.name ?? prompt.participantId,
+              round,
+              content: response.content,
+              timestamp: /* @__PURE__ */ new Date(),
+              tokenCount: response.tokenCount
+            };
+            const modelKey = `${prompt.provider}/${prompt.model}`;
+            const existing = tokenTracker[modelKey] ?? { input: 0, output: 0 };
+            tokenTracker[modelKey] = {
+              input: existing.input + response.tokenCount.input,
+              output: existing.output + response.tokenCount.output
+            };
+            this.emitter.emit("response", message);
+            return message;
+          })
+        );
+        allMessages.push(...roundMessages);
+      }
+      this.emitter.emit("synthesis:start", void 0);
+      const synthesisProviderConfig = this.synthesisProvider ?? {
+        providerId: config.participants[0].provider,
+        model: config.participants[0].model
+      };
+      const provider = this.providers.get(synthesisProviderConfig.providerId);
+      if (!provider) {
+        throw new Error(
+          `Synthesis provider '${synthesisProviderConfig.providerId}' not found`
+        );
+      }
+      const synthesis = await this.synthesizer.synthesize(
+        config,
+        allMessages,
+        provider
+      );
+      const durationMs = Date.now() - startTime;
+      const totalTokens = Object.values(tokenTracker).reduce(
+        (acc, t) => ({
+          input: acc.input + t.input,
+          output: acc.output + t.output
+        }),
+        { input: 0, output: 0 }
+      );
+      const metadata = {
+        totalTokens,
+        durationMs,
+        modelBreakdown: tokenTracker
+      };
+      const result = {
+        config,
+        messages: allMessages,
+        synthesis,
+        metadata
+      };
+      this.emitter.emit("complete", result);
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emitter.emit("error", err);
+      throw err;
+    }
+  }
+};
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  id = "anthropic";
+  client;
+  defaultModel;
+  defaultMaxTokens;
+  constructor(config) {
+    this.client = new Anthropic({ apiKey: config.apiKey });
+    this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+  }
+  async complete(request) {
+    const params = {
+      model: request.model || this.defaultModel,
+      max_tokens: request.maxTokens ?? this.defaultMaxTokens,
+      system: request.systemPrompt,
+      messages: request.messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      ...request.temperature !== void 0 && {
+        temperature: request.temperature
+      }
+    };
+    let response;
+    try {
+      response = await this.client.messages.create(params);
+    } catch (error) {
+      if (isOverloadedError(error)) {
+        await delay(1e3);
+        response = await this.client.messages.create(params);
+      } else {
+        throw error;
+      }
+    }
+    const textBlock = response.content.find(
+      (block) => block.type === "text"
+    );
+    if (!textBlock) {
+      throw new Error(
+        `Anthropic response contained no text block. Stop reason: ${response.stop_reason}`
+      );
+    }
+    return {
+      content: textBlock.text,
+      tokenCount: {
+        input: response.usage.input_tokens,
+        output: response.usage.output_tokens
+      },
+      model: response.model
+    };
+  }
+};
+function isOverloadedError(error) {
+  if (error instanceof Anthropic.APIError) {
+    return error.status === 529;
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/providers/openrouter.ts
+var OpenRouterProvider = class {
+  id = "openrouter";
+  apiKey;
+  appName;
+  defaultModel;
+  defaultMaxTokens;
+  siteUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.appName = config.appName ?? "llm-council";
+    this.defaultModel = config.defaultModel ?? "openai/gpt-4o";
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+    this.siteUrl = config.siteUrl ?? "";
+  }
+  async complete(request) {
+    const body = {
+      model: request.model || this.defaultModel,
+      messages: [
+        { role: "system", content: request.systemPrompt },
+        ...request.messages.map((msg) => ({
+          role: msg.role,
+          content: msg.content
+        }))
+      ],
+      max_tokens: request.maxTokens ?? this.defaultMaxTokens,
+      ...request.temperature !== void 0 && {
+        temperature: request.temperature
+      }
+    };
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "X-Title": this.appName
+    };
+    if (this.siteUrl) {
+      headers["HTTP-Referer"] = this.siteUrl;
+    }
+    let response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 2e3;
+      await delay2(Math.min(delayMs, 1e4));
+      response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+    }
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => null);
+      const message = errorBody?.error?.message ?? `HTTP ${response.status}`;
+      throw new Error(`OpenRouter API error (${response.status}): ${message}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error("OpenRouter response contained no content");
+    }
+    return {
+      content,
+      tokenCount: {
+        input: data.usage?.prompt_tokens ?? 0,
+        output: data.usage?.completion_tokens ?? 0
+      },
+      model: data.model
+    };
+  }
+};
+function delay2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/utils/prompt-builder.ts
+function buildInitialUserMessage(config) {
+  const parts = [];
+  parts.push(`## Decision Topic
+${config.topic}`);
+  if (config.options && config.options.length > 0) {
+    const optionsList = config.options.map((opt, i) => `${i + 1}. ${opt}`).join("\n");
+    parts.push(`## Options
+${optionsList}`);
+  }
+  if (config.preferredOption) {
+    parts.push(`## Preferred Option
+${config.preferredOption}`);
+  }
+  if (config.context) {
+    parts.push(`## Additional Context
+${config.context}`);
+  }
+  parts.push(
+    "Provide your initial brief (200-400 words). State your position clearly and support it with reasoning."
+  );
+  return parts.join("\n\n");
+}
+
+// src/protocols/adversarial.ts
+var DEFAULT_REBUTTAL_GUIDANCE = {
+  proposer: "Focus your rebuttal on the Challenger's strongest attack.",
+  challenger: "Focus on whether the Proposer's acknowledged weakness is actually fatal.",
+  steelmanner: "Focus on whether the Pre-Mortem's failure story applies equally to the rejected option.",
+  "pre-mortem": "Focus on which of the Proposer's assumptions appear in your failure cascade."
+};
+function getRebuttalGuidance(participantId, guidanceMap) {
+  for (const [key, guidance] of Object.entries(guidanceMap)) {
+    if (participantId.toLowerCase().includes(key.toLowerCase())) {
+      return guidance;
+    }
+  }
+  return "Address the most critical point from another member.";
+}
+function buildRebuttalUserMessage(participantId, otherMessages, guidanceMap) {
+  const parts = [];
+  parts.push("Here are the other Council members' briefs:");
+  for (const msg of otherMessages) {
+    parts.push(`### ${msg.participantName}
+${msg.content}`);
+  }
+  const guidance = getRebuttalGuidance(participantId, guidanceMap);
+  parts.push(
+    `Write your rebuttal (100-200 words). ${guidance}`
+  );
+  return parts.join("\n\n");
+}
+var AdversarialProtocol = class {
+  rebuttalGuidance;
+  constructor(options) {
+    this.rebuttalGuidance = options?.rebuttalGuidance ?? DEFAULT_REBUTTAL_GUIDANCE;
+  }
+  getRoundCount() {
+    return 2;
+  }
+  buildPrompts(config, history, round) {
+    if (round === 1) {
+      return this.buildInitialBriefs(config);
+    }
+    if (round === 2) {
+      return this.buildRebuttals(config, history);
+    }
+    return [];
+  }
+  buildInitialBriefs(config) {
+    const userMessage = buildInitialUserMessage(config);
+    return config.participants.map((participant) => ({
+      participantId: participant.id,
+      provider: participant.provider,
+      model: participant.model,
+      systemPrompt: participant.systemPrompt,
+      userMessage,
+      temperature: participant.temperature ?? 0.7,
+      maxTokens: config.tokenBudget?.perResponse
+    }));
+  }
+  buildRebuttals(config, history) {
+    const round1Messages = history.filter((msg) => msg.round === 1);
+    return config.participants.map((participant) => {
+      const otherMessages = round1Messages.filter(
+        (msg) => msg.participantId !== participant.id
+      );
+      return {
+        participantId: participant.id,
+        provider: participant.provider,
+        model: participant.model,
+        systemPrompt: participant.systemPrompt,
+        userMessage: buildRebuttalUserMessage(
+          participant.id,
+          otherMessages,
+          this.rebuttalGuidance
+        ),
+        temperature: participant.temperature ?? 0.7,
+        maxTokens: config.tokenBudget?.perResponse
+      };
+    });
+  }
+};
+
+// src/utils/anonymizer.ts
+var LABELS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+function createAnonymizationMap(participantIds) {
+  const labelToParticipant = /* @__PURE__ */ new Map();
+  const participantToLabel = /* @__PURE__ */ new Map();
+  for (let i = 0; i < participantIds.length; i++) {
+    const label = `Response ${LABELS[i] ?? String(i + 1)}`;
+    labelToParticipant.set(label, participantIds[i]);
+    participantToLabel.set(participantIds[i], label);
+  }
+  return { labelToParticipant, participantToLabel };
+}
+function anonymizeMessages(messages, map) {
+  return messages.map((msg) => ({
+    label: map.participantToLabel.get(msg.participantId) ?? "Unknown",
+    content: msg.content
+  }));
+}
+
+// src/protocols/peer-review.ts
+var PeerReviewProtocol = class {
+  enableRevote;
+  constructor(options) {
+    this.enableRevote = options?.enableRevote ?? false;
+  }
+  getRoundCount() {
+    return this.enableRevote ? 3 : 2;
+  }
+  buildPrompts(config, history, round) {
+    if (round === 1) {
+      return this.buildInitialBriefs(config);
+    }
+    const anonMap = createAnonymizationMap(config.participants.map((p) => p.id));
+    if (round === 2) {
+      return this.buildRankingRound(config, history, anonMap);
+    }
+    if (round === 3 && this.enableRevote) {
+      return this.buildRevoteRound(config, history, anonMap);
+    }
+    return [];
+  }
+  buildInitialBriefs(config) {
+    const userMessage = buildInitialUserMessage(config);
+    return config.participants.map((participant) => ({
+      participantId: participant.id,
+      provider: participant.provider,
+      model: participant.model,
+      systemPrompt: participant.systemPrompt,
+      userMessage,
+      temperature: participant.temperature ?? 0.7,
+      maxTokens: config.tokenBudget?.perResponse
+    }));
+  }
+  buildRankingRound(config, history, anonMap) {
+    const round1Messages = history.filter((msg) => msg.round === 1);
+    const anonymized = anonymizeMessages(round1Messages, anonMap);
+    const briefsText = anonymized.map((entry) => `### ${entry.label}
+${entry.content}`).join("\n\n");
+    const labelList = anonymized.map((e) => e.label).join(", ");
+    return config.participants.map((participant) => ({
+      participantId: participant.id,
+      provider: participant.provider,
+      model: participant.model,
+      systemPrompt: participant.systemPrompt,
+      userMessage: buildRankingUserMessage(briefsText, labelList),
+      temperature: participant.temperature ?? 0.7,
+      maxTokens: config.tokenBudget?.perResponse
+    }));
+  }
+  buildRevoteRound(config, history, anonMap) {
+    const round2Messages = history.filter((msg) => msg.round === 2);
+    const anonymizedRankings = anonymizeMessages(round2Messages, anonMap);
+    const rankingsText = anonymizedRankings.map((entry) => `### ${entry.label}'s Rankings
+${entry.content}`).join("\n\n");
+    const round1Messages = history.filter((msg) => msg.round === 1);
+    const anonymizedBriefs = anonymizeMessages(round1Messages, anonMap);
+    const labelList = anonymizedBriefs.map((e) => e.label).join(", ");
+    return config.participants.map((participant) => ({
+      participantId: participant.id,
+      provider: participant.provider,
+      model: participant.model,
+      systemPrompt: participant.systemPrompt,
+      userMessage: buildRevoteUserMessage(rankingsText, labelList),
+      temperature: participant.temperature ?? 0.7,
+      maxTokens: config.tokenBudget?.perResponse
+    }));
+  }
+};
+function buildRankingUserMessage(briefsText, labelList) {
+  const parts = [];
+  parts.push("You are participating in an anonymized peer review. Below are briefs from all council members (including yours, but you do not know which one is yours).");
+  parts.push(briefsText);
+  parts.push(`Rank ALL responses from best to worst (${labelList}). For each, provide a one-sentence justification.
+
+Respond in EXACTLY this format:
+
+RANKING:
+1. [Label] - [one-sentence justification]
+2. [Label] - [one-sentence justification]
+3. [Label] - [one-sentence justification]
+4. [Label] - [one-sentence justification]`);
+  return parts.join("\n\n");
+}
+function buildRevoteUserMessage(rankingsText, labelList) {
+  const parts = [];
+  parts.push("You have seen the other council members' anonymous rankings. Review them and submit your final ranking.");
+  parts.push(rankingsText);
+  parts.push(`Submit your FINAL ranking of all responses (${labelList}). Consider the other members' perspectives.
+
+Respond in EXACTLY this format:
+
+RANKING:
+1. [Label] - [one-sentence justification]
+2. [Label] - [one-sentence justification]
+3. [Label] - [one-sentence justification]
+4. [Label] - [one-sentence justification]`);
+  return parts.join("\n\n");
+}
+
+// src/utils/synthesis-parser.ts
+function groupMessagesByRound(messages) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const existing = grouped.get(msg.round) ?? [];
+    existing.push(msg);
+    grouped.set(msg.round, existing);
+  }
+  return grouped;
+}
+function buildSynthesisUserMessage(config, messages) {
+  const parts = [];
+  parts.push(`# Decision Topic
+${config.topic}`);
+  if (config.options && config.options.length > 0) {
+    parts.push(`# Options
+${config.options.map((o, i) => `${i + 1}. ${o}`).join("\n")}`);
+  }
+  if (config.preferredOption) {
+    parts.push(`# Preferred Option
+${config.preferredOption}`);
+  }
+  if (config.context) {
+    parts.push(`# Context
+${config.context}`);
+  }
+  const roundLabels = {
+    1: "Initial Briefs",
+    2: "Rebuttals",
+    3: "Final Statements",
+    4: "Closing Arguments",
+    5: "Summary"
+  };
+  const grouped = groupMessagesByRound(messages);
+  const sortedRounds = [...grouped.keys()].sort((a, b) => a - b);
+  for (const round of sortedRounds) {
+    const label = roundLabels[round] ?? `Round ${round}`;
+    const roundMessages = grouped.get(round);
+    if (!roundMessages) continue;
+    parts.push(`## Round ${round}: ${label}`);
+    for (const msg of roundMessages) {
+      parts.push(`### ${msg.participantName}
+${msg.content}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseListSection(raw, header) {
+  const escaped = escapeRegex(header);
+  const pattern = new RegExp(
+    `${escaped}:\\s*\\n((?:- .+(?:\\n|$))*)`,
+    "i"
+  );
+  const match = pattern.exec(raw);
+  if (!match?.[1]) return [];
+  return match[1].split("\n").map((line) => line.replace(/^- /, "").trim()).filter((line) => line.length > 0);
+}
+function parseSynthesisResponse(raw) {
+  const recommendationMatch = /RECOMMENDATION:\s*(.+)/i.exec(raw);
+  const confidenceMatch = /CONFIDENCE:\s*(\d+)/i.exec(raw);
+  const reasoningMatch = /REASONING:\s*(.+(?:\n(?!RISKS:|DISSENT:|VALIDATION_GATES:|ASSUMPTIONS:).+)*)/i.exec(raw);
+  const recommendation = recommendationMatch?.[1]?.trim() ?? raw.slice(0, 200);
+  const confidence = confidenceMatch ? parseInt(confidenceMatch[1], 10) : 50;
+  const reasoning = reasoningMatch?.[1]?.trim() ?? raw;
+  const risks = parseListSection(raw, "RISKS");
+  const dissent = parseListSection(raw, "DISSENT");
+  const validationGates = parseListSection(raw, "VALIDATION_GATES");
+  const assumptions = parseListSection(raw, "ASSUMPTIONS");
+  return {
+    recommendation,
+    confidence: Math.min(100, Math.max(0, confidence)),
+    reasoning,
+    risks,
+    dissent,
+    validationGates,
+    assumptions,
+    raw
+  };
+}
+
+// src/synthesis/dialectical.ts
+var SYSTEM_PROMPT = `You are the Synthesis Moderator for a council deliberation. You have received briefs and rebuttals from multiple council members debating a decision. Your job is to:
+1. Weigh evidence over opinion - arguments backed by specific data or precedent outweigh assertions
+2. Favor reversibility when confidence is low - if the council is split, recommend the more reversible option
+3. Synthesize, don't average - your recommendation should reflect the strongest arguments, not a compromise
+4. Calibrate confidence honestly: 90%+ = unanimous agreement with strong evidence; 70-89% = majority with minor dissent; 50-69% = significant split or unknowns; <50% = fundamental disagreement, recommend gathering more data
+
+Respond in EXACTLY this format (no deviations):
+
+RECOMMENDATION: [one sentence]
+CONFIDENCE: [number 0-100]
+REASONING: [2-3 sentences explaining the recommendation]
+RISKS:
+- [risk 1]
+- [risk 2]
+- [risk 3]
+DISSENT:
+- [strongest counter-argument that survived debate]
+VALIDATION_GATES:
+- [gate 1 - measurable, time-bound]
+- [gate 2]
+ASSUMPTIONS:
+- [assumption 1 that must hold]
+- [assumption 2]`;
+var DialecticalSynthesizer = class {
+  model;
+  temperature;
+  constructor(options = {}) {
+    this.model = options.model ?? "claude-sonnet-4-20250514";
+    this.temperature = options.temperature ?? 0.3;
+  }
+  async synthesize(config, messages, provider) {
+    const userMessage = buildSynthesisUserMessage(config, messages);
+    const response = await provider.complete({
+      model: this.model,
+      systemPrompt: SYSTEM_PROMPT,
+      messages: [{ role: "user", content: userMessage }],
+      temperature: this.temperature
+    });
+    return parseSynthesisResponse(response.content);
+  }
+};
+
+// src/synthesis/chairman.ts
+var SYSTEM_PROMPT2 = `You are the Chairman of a council deliberation. Your job is to evaluate the arguments presented and SELECT THE BEST ONE. Do not synthesize or merge arguments. Pick the winner.
+
+Evaluation criteria:
+1. Evidence quality - arguments backed by specific data, precedent, or measurable outcomes score highest
+2. Risk awareness - the best argument acknowledges its own weaknesses honestly
+3. Actionability - prefer arguments with clear, concrete next steps over abstract reasoning
+4. Logical coherence - the argument's conclusion must follow from its premises
+
+Your confidence score reflects how clear the winner is:
+- 90%+ = one argument is clearly superior, others have significant flaws
+- 70-89% = a clear winner exists but the runner-up has merit
+- 50-69% = close race between two or more arguments
+- <50% = no clear winner, recommend gathering more data
+
+Respond in EXACTLY this format (no deviations):
+
+RECOMMENDATION: [state which participant's argument wins and why in one sentence]
+CONFIDENCE: [number 0-100]
+REASONING: [2-3 sentences explaining why this argument won over the others]
+RISKS:
+- [risk 1 from the winning argument]
+- [risk 2]
+- [risk 3]
+DISSENT:
+- [the runner-up's strongest point that nearly won]
+VALIDATION_GATES:
+- [gate 1 - measurable, time-bound]
+- [gate 2]
+ASSUMPTIONS:
+- [assumption 1 the winning argument depends on]
+- [assumption 2]`;
+var ChairmanSynthesizer = class {
+  model;
+  temperature;
+  constructor(options = {}) {
+    this.model = options.model ?? "claude-sonnet-4-20250514";
+    this.temperature = options.temperature ?? 0.3;
+  }
+  async synthesize(config, messages, provider) {
+    const userMessage = buildSynthesisUserMessage(config, messages);
+    const response = await provider.complete({
+      model: this.model,
+      systemPrompt: SYSTEM_PROMPT2,
+      messages: [{ role: "user", content: userMessage }],
+      temperature: this.temperature
+    });
+    return parseSynthesisResponse(response.content);
+  }
+};
+
+// src/personas/presets.ts
+var proposer = {
+  id: "proposer",
+  name: "Proposer",
+  systemPrompt: `# Proposer \u2014 Thesis Builder
+
+## Role
+You are the Proposer. Your job is to build the strongest possible case FOR the preferred option. You are an advocate, not a neutral analyst.
+
+## Cognitive Stance
+Dialectical Inquiry: construct the thesis that will be tested by the other Council members. Your case must be rigorous enough to survive attack.
+
+## What You Must Do
+1. State the recommendation clearly \u2014 one sentence, no hedging
+2. List 3-5 supporting arguments \u2014 each backed by evidence, logic, or precedent from the decision context
+3. List explicit assumptions \u2014 what must be true for this option to succeed. Be honest. Hidden assumptions are the Challenger's ammunition.
+4. Identify the best-case outcome \u2014 what does success look like in 3, 6, 12 months?
+5. Acknowledge the weakest point \u2014 every thesis has one. Name it.
+
+## Output Format
+## Proposer Brief
+
+**Recommendation:** [one sentence]
+
+**Supporting arguments:**
+1. [argument + evidence]
+2. [argument + evidence]
+3. [argument + evidence]
+
+**Assumptions (what must be true):**
+- [assumption 1]
+- [assumption 2]
+- [assumption 3]
+
+**Best-case outcome:** [description]
+
+**Weakest point:** [honest acknowledgment]
+
+## Rules
+- 200-400 words max
+- No padding, no filler \u2014 state assertions directly
+- Every argument must reference specific context (constraints, numbers, precedents)
+- Do NOT address the other agents \u2014 write your brief independently`,
+  temperature: 0.7
+};
+var challenger = {
+  id: "challenger",
+  name: "Challenger",
+  systemPrompt: `# Challenger \u2014 Red Team Attacker
+
+## Role
+You are the Challenger. Your job is to attack the preferred option. Find every vulnerability, hidden cost, second-order effect, and competitive risk. You are the red team.
+
+## Cognitive Stance
+Red Team + Devil's Advocate: assume the preferred option has fatal flaws. Your job is to find them before reality does.
+
+## What You Must Do
+1. Attack the assumptions \u2014 take each assumption from the proposal and stress-test it. What if it's wrong?
+2. Find hidden costs \u2014 time, money, opportunity cost, relationship cost, reputation risk not in the initial analysis
+3. Identify second-order effects \u2014 what happens AFTER the decision? What does it trigger, close off, or commit to?
+4. Surface competitive risks \u2014 what can go wrong externally? Market changes, competitor moves, timing risks
+5. Ask the question they're avoiding \u2014 every decision has one uncomfortable question nobody wants to ask. Ask it.
+
+## Output Format
+## Challenger Brief
+
+**Verdict:** [one sentence \u2014 is this option as strong as it looks?]
+
+**Assumption attacks:**
+- [assumption] -> [why it might be wrong]
+- [assumption] -> [why it might be wrong]
+
+**Hidden costs:**
+- [cost 1]
+- [cost 2]
+
+**Second-order effects:**
+- [effect \u2014 what this triggers or closes off]
+
+**The question they're avoiding:**
+[one uncomfortable question]
+
+**Kill condition:** [the single scenario where this option catastrophically fails]
+
+## Rules
+- 200-400 words max
+- Be aggressive but honest \u2014 attack the option, not the person
+- Every attack must be specific, not vague
+- Do NOT propose alternatives \u2014 that's the Steelmanner's job
+- Do NOT soften your attacks \u2014 the whole point is adversarial pressure`,
+  temperature: 0.7
+};
+var steelmanner = {
+  id: "steelmanner",
+  name: "Steelmanner",
+  systemPrompt: `# Steelmanner \u2014 Counter-Proposal Advocate
+
+## Role
+You are the Steelmanner. Your job is to take the option the decision-maker is leaning AWAY from and build the absolute best case for it. Not criticism of the preferred option \u2014 genuine, full-throated advocacy for the alternative.
+
+## Cognitive Stance
+Rationalist steelmanning: assume the rejected option has merits being overlooked due to anchoring bias, status quo preference, or emotional attachment to the preferred path.
+
+## What You Must Do
+1. Reframe the rejected option \u2014 present it in its most favorable light. What would a brilliant advocate say?
+2. Find unique advantages \u2014 what does this option offer that the preferred option cannot? Focus on exclusive benefits.
+3. Address the objections \u2014 why is the decision-maker leaning away? Take each objection and counter it with evidence or reframing.
+4. Paint the success scenario \u2014 if this option were chosen and executed well, what does the best outcome look like?
+5. Identify the regret scenario \u2014 in what future does the decision-maker wish they had chosen this path instead?
+
+## Output Format
+## Steelmanner Brief
+
+**The case for [rejected option]:**
+[2-3 sentence reframe \u2014 why this deserves serious consideration]
+
+**Unique advantages:**
+- [advantage 1 \u2014 something the preferred option cannot offer]
+- [advantage 2]
+- [advantage 3]
+
+**Objection rebuttals:**
+- "[objection]" -> [counter-argument]
+- "[objection]" -> [counter-argument]
+
+**Success scenario:** [what the best outcome looks like]
+
+**Regret scenario:** [in what future does choosing the other path feel like a mistake?]
+
+## Rules
+- 200-400 words max
+- Genuine advocacy, not token opposition \u2014 actually try to convince
+- Do NOT attack the preferred option (the Challenger does that)
+- Do NOT be balanced \u2014 be biased toward the rejected option. That's the point.
+- If there are multiple rejected options, steelman the strongest one`,
+  temperature: 0.7
+};
+var preMortem = {
+  id: "pre-mortem",
+  name: "Pre-Mortem",
+  systemPrompt: `# Pre-Mortem \u2014 Failure Narrator
+
+## Role
+You are the Pre-Mortem analyst. Your job is to assume the preferred option was chosen, time has passed, and it has failed. Narrate the failure story \u2014 how it happened, when it went wrong, and why nobody saw it coming.
+
+## Cognitive Stance
+Klein's Pre-Mortem: by assuming failure has already occurred, you bypass optimism bias and unlock prospective hindsight. Research shows this surfaces 30% more risks than traditional risk analysis.
+
+## What You Must Do
+1. Set the scene \u2014 pick a realistic timeframe (3 months? 6 months? 1 year?) and describe the moment of failure
+2. Narrate the failure story in past tense \u2014 "The decision was made on [date]. The first sign of trouble appeared when..." Write it as a retrospective.
+3. Identify the specific failure modes \u2014 not vague "it didn't work" but concrete mechanisms
+4. Trace the cascade \u2014 how did one failure lead to another? What was the domino chain?
+5. Find the turning point \u2014 the single moment where intervention could have prevented the failure. This becomes a validation gate.
+
+## Output Format
+## Pre-Mortem Brief
+
+**Timeframe:** [when the failure becomes apparent]
+
+**The failure story:**
+[3-5 sentences in past tense narrating what went wrong]
+
+**Failure modes:**
+1. [specific mechanism of failure]
+2. [specific mechanism of failure]
+3. [specific mechanism of failure]
+
+**Cascade effect:**
+[how failure mode 1 led to 2 led to 3]
+
+**The turning point:**
+[the moment where intervention would have saved it \u2014 this becomes a validation gate]
+
+**Early warning signs:**
+- [signal 1 \u2014 what to watch for]
+- [signal 2 \u2014 what to watch for]
+
+## Rules
+- 200-400 words max
+- Write in past tense \u2014 the failure has already happened
+- Be specific about mechanisms, not vague about outcomes
+- Use real constraints from the decision context
+- The failure must be plausible, not catastrophic fantasy
+- Do NOT suggest solutions \u2014 the Synthesizer handles that`,
+  temperature: 0.7
+};
+var PERSONAS = {
+  proposer,
+  challenger,
+  steelmanner,
+  preMortem
+};
+
+// src/cli.ts
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var red = (s) => `\x1B[31m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var HELP = `
+${bold("llm-council")} \u2014 Multi-model deliberation engine
+
+${bold("USAGE")}
+  llm-council "Should we adopt microservices?"
+  llm-council --provider openrouter --model openai/gpt-4o "topic"
+  llm-council --config council.json "topic"
+
+${bold("OPTIONS")}
+  --provider     ${dim("anthropic | openrouter")}        ${dim("(default: anthropic)")}
+  --protocol     ${dim("adversarial | peer-review")}     ${dim("(default: adversarial)")}
+  --synthesizer  ${dim("dialectical | chairman")}        ${dim("(default: dialectical)")}
+  --model        ${dim("model ID for all participants")}  ${dim("(default: provider-dependent)")}
+  --revote       ${dim("enable 3rd round re-vote (peer-review only)")}
+  --config       ${dim("path to JSON config file")}
+  --help         ${dim("show this help")}
+
+${bold("ENVIRONMENT")}
+  ANTHROPIC_API_KEY     Required when --provider=anthropic
+  OPENROUTER_API_KEY    Required when --provider=openrouter
+
+${bold("CONFIG FILE")}
+  {
+    "provider": "openrouter",
+    "protocol": "adversarial",
+    "synthesizer": "dialectical",
+    "model": "openai/gpt-4o"
+  }
+`;
+function resolveConfig(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      provider: { type: "string", default: "anthropic" },
+      protocol: { type: "string", default: "adversarial" },
+      synthesizer: { type: "string", default: "dialectical" },
+      model: { type: "string" },
+      revote: { type: "boolean", default: false },
+      config: { type: "string" },
+      help: { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    process.stdout.write(HELP);
+    process.exit(0);
+  }
+  let fileConfig = {};
+  if (values.config) {
+    const raw = readFileSync(values.config, "utf-8");
+    fileConfig = JSON.parse(raw);
+  }
+  const providerName = values.provider ?? fileConfig.provider ?? "anthropic";
+  const protocolName = values.protocol ?? fileConfig.protocol ?? "adversarial";
+  const synthesizerName = values.synthesizer ?? fileConfig.synthesizer ?? "dialectical";
+  const modelOverride = values.model ?? fileConfig.model;
+  const topic = positionals[0];
+  if (!topic) {
+    process.stderr.write(red('Error: topic is required. Usage: llm-council "your topic"\n'));
+    process.exit(1);
+  }
+  const provider = resolveProvider(providerName, modelOverride);
+  const enableRevote = values.revote ?? false;
+  const protocol = resolveProtocol(protocolName, enableRevote);
+  const synthesizer = resolveSynthesizer(synthesizerName, modelOverride);
+  const model = modelOverride ?? getDefaultModel(providerName);
+  const participants = [
+    { ...PERSONAS.proposer, provider: providerName, model },
+    { ...PERSONAS.challenger, provider: providerName, model },
+    { ...PERSONAS.steelmanner, provider: providerName, model },
+    { ...PERSONAS.preMortem, provider: providerName, model }
+  ];
+  const rounds = protocol.getRoundCount();
+  return { provider, protocol, synthesizer, participants, topic, rounds };
+}
+function resolveProvider(name, modelOverride) {
+  switch (name) {
+    case "anthropic": {
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) {
+        process.stderr.write(red("Error: ANTHROPIC_API_KEY environment variable is required\n"));
+        process.exit(1);
+      }
+      return new AnthropicProvider({
+        apiKey,
+        ...modelOverride && { defaultModel: modelOverride }
+      });
+    }
+    case "openrouter": {
+      const apiKey = process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        process.stderr.write(red("Error: OPENROUTER_API_KEY environment variable is required\n"));
+        process.exit(1);
+      }
+      return new OpenRouterProvider({
+        apiKey,
+        appName: "llm-council",
+        ...modelOverride && { defaultModel: modelOverride }
+      });
+    }
+    default:
+      process.stderr.write(red(`Error: unknown provider "${name}". Use: anthropic, openrouter
+`));
+      process.exit(1);
+  }
+}
+function resolveProtocol(name, enableRevote) {
+  switch (name) {
+    case "adversarial":
+      return new AdversarialProtocol();
+    case "peer-review":
+      return new PeerReviewProtocol({ enableRevote });
+    default:
+      process.stderr.write(red(`Error: unknown protocol "${name}". Use: adversarial, peer-review
+`));
+      process.exit(1);
+  }
+}
+function resolveSynthesizer(name, modelOverride) {
+  switch (name) {
+    case "dialectical":
+      return new DialecticalSynthesizer(modelOverride ? { model: modelOverride } : {});
+    case "chairman":
+      return new ChairmanSynthesizer(modelOverride ? { model: modelOverride } : {});
+    default:
+      process.stderr.write(red(`Error: unknown synthesizer "${name}". Use: dialectical, chairman
+`));
+      process.exit(1);
+  }
+}
+function getDefaultModel(providerName) {
+  switch (providerName) {
+    case "anthropic":
+      return "claude-sonnet-4-20250514";
+    case "openrouter":
+      return "openai/gpt-4o";
+    default:
+      return "claude-sonnet-4-20250514";
+  }
+}
+async function main() {
+  const resolved = resolveConfig(process.argv.slice(2));
+  const config = {
+    topic: resolved.topic,
+    participants: resolved.participants,
+    rounds: resolved.rounds
+  };
+  const providerName = resolved.participants[0].provider;
+  const providers = /* @__PURE__ */ new Map([[providerName, resolved.provider]]);
+  const council = new Council({
+    providers,
+    protocol: resolved.protocol,
+    synthesizer: resolved.synthesizer
+  });
+  process.stdout.write(`
+${bold("LLM Council")} \u2014 deliberating on: ${cyan(config.topic)}
+
+`);
+  council.on("round:start", ({ round, participantCount }) => {
+    process.stdout.write(cyan(`Round ${round} \u2014 ${participantCount} participants
+`));
+  });
+  council.on("response", (msg) => {
+    process.stdout.write(dim(`  ${msg.participantName} responded (${msg.tokenCount.output} tokens)
+`));
+  });
+  council.on("synthesis:start", () => {
+    process.stdout.write(yellow("\nSynthesizing...\n"));
+  });
+  const result = await council.deliberate(config);
+  process.stdout.write(`
+${bold(green("RECOMMENDATION"))}
+`);
+  process.stdout.write(`${result.synthesis.recommendation}
+
+`);
+  process.stdout.write(`${bold("Confidence:")} ${formatConfidence(result.synthesis.confidence)}
+
+`);
+  process.stdout.write(`${bold("Reasoning:")}
+${result.synthesis.reasoning}
+
+`);
+  if (result.synthesis.risks.length > 0) {
+    process.stdout.write(`${bold("Risks:")}
+`);
+    for (const risk of result.synthesis.risks) {
+      process.stdout.write(`  ${red("!")} ${risk}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (result.synthesis.dissent.length > 0) {
+    process.stdout.write(`${bold("Dissent:")}
+`);
+    for (const d of result.synthesis.dissent) {
+      process.stdout.write(`  ${yellow(">")} ${d}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (result.synthesis.validationGates.length > 0) {
+    process.stdout.write(`${bold("Validation Gates:")}
+`);
+    for (const gate of result.synthesis.validationGates) {
+      process.stdout.write(`  ${green("*")} ${gate}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  const total = result.metadata.totalTokens;
+  const durationSec = (result.metadata.durationMs / 1e3).toFixed(1);
+  process.stdout.write(dim(`Tokens: ${total.input} in / ${total.output} out | Duration: ${durationSec}s
+`));
+}
+function formatConfidence(confidence) {
+  if (confidence >= 90) return green(`${confidence}% (high)`);
+  if (confidence >= 70) return green(`${confidence}% (moderate-high)`);
+  if (confidence >= 50) return yellow(`${confidence}% (moderate)`);
+  return red(`${confidence}% (low)`);
+}
+var isTesting = process.env.VITEST === "true" || process.env.NODE_ENV === "test";
+if (!isTesting) {
+  main().catch((error) => {
+    process.stderr.write(red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  });
+}
+export {
+  resolveConfig
+};