adversarial-mirror 0.1.0

package/dist/cli.js

@@ -0,0 +1,2319 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/chat.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+import React2 from "react";
+import { render } from "ink";
+
+// src/brains/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicAdapter = class {
+  id;
+  provider = "anthropic";
+  capabilities = { streaming: true };
+  client;
+  model;
+  constructor(id, model, apiKeyEnvVar) {
+    this.id = id;
+    this.model = model;
+    const apiKey = process.env[apiKeyEnvVar];
+    if (!apiKey) {
+      throw new Error(
+        `Missing API key. Set ${apiKeyEnvVar} or enable MOCK_BRAINS=true.`
+      );
+    }
+    this.client = new Anthropic({ apiKey });
+  }
+  async ping() {
+    const start = Date.now();
+    try {
+      await this.client.messages.create({
+        model: this.model,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return { ok: true, latencyMs: Date.now() - start };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+  async *chat(messages, systemPrompt, options) {
+    const filtered = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: m.content
+    }));
+    const stream = this.client.messages.stream(
+      {
+        model: this.model,
+        max_tokens: options?.maxTokens ?? 1024,
+        system: systemPrompt,
+        messages: filtered
+      },
+      { signal: options?.signal }
+    );
+    let text = "";
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        const delta = event.delta.text;
+        text += delta;
+        yield { delta, isFinal: false };
+      }
+    }
+    const finalMessage = await stream.finalMessage();
+    const inputTokens = finalMessage.usage.input_tokens;
+    const outputTokens = finalMessage.usage.output_tokens;
+    yield { delta: "", isFinal: true, inputTokens, outputTokens };
+    return { text, inputTokens, outputTokens };
+  }
+  estimateTokens(messages) {
+    return messages.reduce((sum, msg) => sum + msg.content.length, 0);
+  }
+  async dispose() {
+    return;
+  }
+};
+
+// src/brains/gemini.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+var GeminiAdapter = class {
+  id;
+  provider = "gemini";
+  capabilities = { streaming: true };
+  model;
+  client;
+  constructor(id, model, apiKeyEnvVar) {
+    this.id = id;
+    this.model = model;
+    const apiKey = process.env[apiKeyEnvVar];
+    if (!apiKey) {
+      throw new Error(
+        `Missing API key. Set ${apiKeyEnvVar} or enable MOCK_BRAINS=true.`
+      );
+    }
+    this.client = new GoogleGenerativeAI(apiKey);
+  }
+  async ping() {
+    return { ok: true };
+  }
+  async *chat(messages, systemPrompt, options) {
+    const model = this.client.getGenerativeModel({ model: this.model });
+    const contents = messages.filter((message) => message.role !== "system").map((message) => ({
+      role: message.role === "assistant" ? "model" : "user",
+      parts: [{ text: message.content }]
+    }));
+    const result = await model.generateContentStream({
+      contents,
+      systemInstruction: {
+        role: "system",
+        parts: [{ text: systemPrompt }]
+      },
+      generationConfig: {
+        temperature: options?.temperature,
+        maxOutputTokens: options?.maxTokens
+      }
+    });
+    let text = "";
+    for await (const chunk of result.stream) {
+      const delta = chunk.text();
+      if (delta) {
+        text += delta;
+        yield { delta, isFinal: false };
+      }
+    }
+    let inputTokens;
+    let outputTokens;
+    try {
+      const response2 = await result.response;
+      const usage = response2.usageMetadata;
+      if (usage) {
+        inputTokens = usage.promptTokenCount;
+        outputTokens = usage.candidatesTokenCount ?? usage.totalTokenCount ?? void 0;
+      }
+    } catch {
+    }
+    const response = { text, inputTokens, outputTokens };
+    yield { delta: "", isFinal: true, inputTokens, outputTokens };
+    return response;
+  }
+  estimateTokens(messages) {
+    return messages.reduce((sum, msg) => sum + msg.content.length, 0);
+  }
+  async dispose() {
+    return;
+  }
+};
+
+// src/brains/mock.ts
+var MockAdapter = class {
+  id;
+  provider = "mock";
+  capabilities = { streaming: true };
+  responseText;
+  constructor(id, responseText = "Mock response.") {
+    this.id = id;
+    this.responseText = responseText;
+  }
+  async ping() {
+    return { ok: true, latencyMs: 1 };
+  }
+  async *chat(_messages, _systemPrompt, _options) {
+    for (const chunk of this.responseText.split(" ")) {
+      yield { delta: `${chunk} `, isFinal: false };
+    }
+    const response = { text: this.responseText };
+    yield { delta: "", isFinal: true };
+    return response;
+  }
+  estimateTokens(messages) {
+    return messages.reduce((sum, msg) => sum + msg.content.length, 0);
+  }
+  async dispose() {
+    return;
+  }
+};
+
+// src/brains/openai.ts
+import OpenAI from "openai";
+var OpenAIAdapter = class {
+  id;
+  provider = "openai";
+  capabilities = { streaming: true };
+  model;
+  client;
+  constructor(id, model, apiKeyEnvVar) {
+    this.id = id;
+    this.model = model;
+    const apiKey = process.env[apiKeyEnvVar];
+    if (!apiKey) {
+      throw new Error(
+        `Missing API key. Set ${apiKeyEnvVar} or enable MOCK_BRAINS=true.`
+      );
+    }
+    this.client = new OpenAI({ apiKey });
+  }
+  async ping() {
+    const start = Date.now();
+    try {
+      await this.client.models.list();
+      return { ok: true, latencyMs: Date.now() - start };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+  async *chat(messages, systemPrompt, options) {
+    const stream = await this.client.chat.completions.create(
+      {
+        model: this.model,
+        stream: true,
+        stream_options: { include_usage: true },
+        temperature: options?.temperature,
+        max_tokens: options?.maxTokens,
+        messages: [
+          { role: "system", content: systemPrompt },
+          ...messages.filter((message) => message.role !== "system").map((message) => ({
+            role: message.role === "assistant" ? "assistant" : "user",
+            content: message.content
+          }))
+        ]
+      },
+      { signal: options?.signal }
+    );
+    let text = "";
+    let inputTokens;
+    let outputTokens;
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta?.content ?? "";
+      if (delta) {
+        text += delta;
+        yield { delta, isFinal: false };
+      }
+      if (chunk.usage) {
+        inputTokens = chunk.usage.prompt_tokens;
+        outputTokens = chunk.usage.completion_tokens;
+      }
+    }
+    const response = {
+      text,
+      inputTokens,
+      outputTokens
+    };
+    yield { delta: "", isFinal: true, inputTokens, outputTokens };
+    return response;
+  }
+  estimateTokens(messages) {
+    return messages.reduce((sum, msg) => sum + msg.content.length, 0);
+  }
+  async dispose() {
+    return;
+  }
+};
+
+// src/brains/factory.ts
+function createAdapter(config2, overrides = {}) {
+  const effective = { ...config2, ...overrides };
+  if (process.env.MOCK_BRAINS) {
+    return new MockAdapter(effective.id, `Mock response from ${effective.id}.`);
+  }
+  switch (effective.provider) {
+    case "anthropic":
+      return new AnthropicAdapter(
+        effective.id,
+        effective.model,
+        effective.apiKeyEnvVar
+      );
+    case "openai":
+      return new OpenAIAdapter(
+        effective.id,
+        effective.model,
+        effective.apiKeyEnvVar
+      );
+    case "gemini":
+      return new GeminiAdapter(
+        effective.id,
+        effective.model,
+        effective.apiKeyEnvVar
+      );
+    case "mock":
+      return new MockAdapter(effective.id, `Mock response from ${effective.id}.`);
+    default:
+      throw new Error(`Unsupported provider: ${effective.provider}`);
+  }
+}
+
+// src/config/loader.ts
+import Conf from "conf";
+
+// src/config/schema.ts
+import { z } from "zod";
+var brainConfigSchema = z.object({
+  id: z.string().min(1),
+  provider: z.enum(["anthropic", "openai", "gemini", "mock"]),
+  model: z.string().min(1),
+  apiKeyEnvVar: z.string().min(1)
+});
+var configSchema = z.object({
+  version: z.number().int().positive(),
+  session: z.object({
+    originalBrainId: z.string().min(1),
+    challengerBrainId: z.string().min(1),
+    defaultIntensity: z.enum(["mild", "moderate", "aggressive"]),
+    historyWindowSize: z.number().int().positive(),
+    autoClassify: z.boolean(),
+    judgeEnabled: z.boolean().default(true),
+    judgeBrainId: z.string().min(1).default("claude-sonnet-4-6"),
+    defaultPersona: z.string().optional()
+  }),
+  ui: z.object({
+    layout: z.enum(["side-by-side", "stacked"]),
+    showTokenCounts: z.boolean(),
+    showLatency: z.boolean(),
+    syntaxHighlighting: z.boolean()
+  }),
+  brains: z.array(brainConfigSchema).min(1),
+  classifier: z.object({
+    brainId: z.string().min(1),
+    model: z.string().min(1),
+    confidenceThreshold: z.number().min(0).max(1)
+  })
+});
+
+// src/config/defaults.ts
+var defaultConfig = {
+  version: 1,
+  session: {
+    originalBrainId: "claude-sonnet-4-6",
+    challengerBrainId: "gpt-4o",
+    defaultIntensity: "moderate",
+    historyWindowSize: 20,
+    autoClassify: true,
+    judgeEnabled: true,
+    judgeBrainId: "claude-sonnet-4-6",
+    defaultPersona: void 0
+  },
+  ui: {
+    layout: "side-by-side",
+    showTokenCounts: false,
+    showLatency: true,
+    syntaxHighlighting: true
+  },
+  brains: [
+    {
+      id: "claude-sonnet-4-6",
+      provider: "anthropic",
+      model: "claude-sonnet-4-6",
+      apiKeyEnvVar: "ANTHROPIC_API_KEY"
+    },
+    {
+      id: "gpt-4o",
+      provider: "openai",
+      model: "gpt-4o",
+      apiKeyEnvVar: "OPENAI_API_KEY"
+    },
+    {
+      id: "o3-mini",
+      provider: "openai",
+      model: "o3-mini",
+      apiKeyEnvVar: "OPENAI_API_KEY"
+    },
+    {
+      id: "gemini-pro",
+      provider: "gemini",
+      model: "gemini-2.5-pro",
+      apiKeyEnvVar: "GOOGLE_API_KEY"
+    }
+  ],
+  classifier: {
+    brainId: "claude-sonnet-4-6",
+    model: "claude-haiku-4-5-20251001",
+    confidenceThreshold: 0.75
+  }
+};
+
+// src/config/loader.ts
+var store = new Conf({
+  projectName: "adversarial-mirror",
+  configName: "config",
+  defaults: defaultConfig
+});
+function loadConfig() {
+  return configSchema.parse(store.store);
+}
+function saveConfig(next) {
+  store.store = configSchema.parse(next);
+}
+function setConfigValue(path, value) {
+  const current = loadConfig();
+  const updated = setByPath({ ...current }, path, value);
+  saveConfig(updated);
+  return updated;
+}
+function setByPath(config2, path, value) {
+  const keys = path.split(".").filter(Boolean);
+  if (keys.length === 0) {
+    return config2;
+  }
+  let cursor = config2;
+  for (let i = 0; i < keys.length - 1; i += 1) {
+    const key = keys[i];
+    if (typeof cursor[key] !== "object" || cursor[key] === null) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[keys[keys.length - 1]] = value;
+  return config2;
+}
+
+// src/engine/intent-classifier.ts
+var intentSystemPrompt = `You are an intent classifier for a CLI assistant. 
+Return strict JSON with keys: category, shouldMirror, confidence, reason.
+Categories: factual_lookup, math_computation, code_task, conversational, opinion_advice, analysis, interpretation, prediction.
+Rules:
+- factual_lookup, math_computation, code_task, conversational => shouldMirror false
+- opinion_advice, analysis, interpretation, prediction => shouldMirror true
+Confidence is 0-1.
+Return ONLY JSON.`;
+var HeuristicIntentClassifier = class {
+  async classify(input3) {
+    const trimmed = input3.trim().toLowerCase();
+    const looksFactual = trimmed.startsWith("who ") || trimmed.startsWith("what ") || trimmed.startsWith("when ") || trimmed.startsWith("where ");
+    const category = looksFactual ? "factual_lookup" : "analysis";
+    const shouldMirror = !looksFactual;
+    return {
+      category,
+      shouldMirror,
+      confidence: looksFactual ? 0.55 : 0.45,
+      reason: looksFactual ? "Heuristic: question starts with who/what/when/where." : "Heuristic: default to analysis for open-ended prompts."
+    };
+  }
+};
+var BrainIntentClassifier = class {
+  adapter;
+  threshold;
+  constructor(adapter, threshold = 0.75) {
+    this.adapter = adapter;
+    this.threshold = threshold;
+  }
+  async classify(input3) {
+    const messages = [{ role: "user", content: input3 }];
+    const options = { temperature: 0 };
+    const stream = this.adapter.chat(messages, intentSystemPrompt, options);
+    let text = "";
+    for await (const chunk of stream) {
+      if (chunk.delta) {
+        text += chunk.delta;
+      }
+    }
+    const parsed = safeParseIntent(text);
+    const category = parsed.category;
+    const shouldMirror = parsed.shouldMirror;
+    const confidence = parsed.confidence;
+    if (confidence < this.threshold) {
+      return {
+        ...parsed,
+        shouldMirror: true,
+        reason: `${parsed.reason} (below confidence threshold ${this.threshold}).`
+      };
+    }
+    return {
+      category,
+      shouldMirror,
+      confidence,
+      reason: parsed.reason
+    };
+  }
+};
+function safeParseIntent(text) {
+  const trimmed = text.trim();
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Classifier returned non-JSON output.");
+  }
+  const json = trimmed.slice(start, end + 1);
+  const parsed = JSON.parse(json);
+  const category = normalizeCategory(parsed.category);
+  const confidence = clamp(
+    typeof parsed.confidence === "number" ? parsed.confidence : 0
+  );
+  const shouldMirror = typeof parsed.shouldMirror === "boolean" ? parsed.shouldMirror : ["opinion_advice", "analysis", "interpretation", "prediction"].includes(
+    category
+  );
+  const reason = typeof parsed.reason === "string" && parsed.reason ? parsed.reason : "No reason provided.";
+  return { category, shouldMirror, confidence, reason };
+}
+function normalizeCategory(value) {
+  const allowed = [
+    "factual_lookup",
+    "math_computation",
+    "code_task",
+    "conversational",
+    "opinion_advice",
+    "analysis",
+    "interpretation",
+    "prediction"
+  ];
+  if (typeof value === "string" && allowed.includes(value)) {
+    return value;
+  }
+  return "analysis";
+}
+function clamp(value) {
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+
+// src/engine/classifier-factory.ts
+function buildIntentClassifier(config2, debug = false) {
+  const classifierConfig = config2.classifier;
+  const brainConfig = config2.brains.find(
+    (brain) => brain.id === classifierConfig.brainId
+  );
+  if (!brainConfig) {
+    if (debug) {
+      process.stderr.write(
+        `[debug] Classifier brain not found: ${classifierConfig.brainId}. Using heuristic.
+`
+      );
+    }
+    return new HeuristicIntentClassifier();
+  }
+  try {
+    const adapter = createAdapter(brainConfig, { model: classifierConfig.model });
+    return new BrainIntentClassifier(
+      adapter,
+      classifierConfig.confidenceThreshold
+    );
+  } catch (error) {
+    if (debug) {
+      process.stderr.write(
+        `[debug] Failed to init classifier: ${error.message}. Using heuristic.
+`
+      );
+    }
+    return new HeuristicIntentClassifier();
+  }
+}
+
+// src/engine/prompt-builder.ts
+var baseRule = "Every point must have a specific mechanism. Vague doubt is useless.";
+var mild = `You are a gentle critic. Provide a full answer, then 1-2 real gaps and a steelman alternative. ${baseRule}`;
+var moderate = `You are a devil's advocate.
+1. REFRAME the implicit assumption.
+2. CHALLENGE THE FRAME with the question the user should have asked.
+3. SURFACE HIDDEN COSTS that are under-weighted.
+4. STRONGEST COUNTERPOSITION (no straw man).
+5. VERDICT with honest synthesis.
+${baseRule}`;
+var aggressive = `You are adversarial.
+1. BURIED ASSUMPTION: the most consequential unstated assumption.
+2. STRONGEST REFUTATION against the dominant view.
+3. FAILURE CASES: 2-3 concrete scenarios where standard advice fails.
+4. EXPERT DISSENT: represent serious dissenting thinkers.
+5. HONEST SYNTHESIS with calibrated confidence.
+${baseRule}`;
+function buildChallengerPrompt(intensity) {
+  switch (intensity) {
+    case "mild":
+      return mild;
+    case "moderate":
+      return moderate;
+    case "aggressive":
+      return aggressive;
+    default:
+      return moderate;
+  }
+}
+function buildOriginalPrompt() {
+  return "You are the primary assistant. Provide the best direct answer.";
+}
+var PERSONAS = {
+  "vc-skeptic": {
+    label: "VC Skeptic",
+    lens: "Investor/VC scrutiny",
+    focusAreas: [
+      "Market sizing assumptions \u2014 are they realistic or aspirational?",
+      "Unit economics \u2014 does the math work at scale?",
+      "Competitive moat \u2014 what stops a well-funded competitor from copying this?",
+      "Defensibility \u2014 what makes this durable beyond 18 months?"
+    ]
+  },
+  "security-auditor": {
+    label: "Security Auditor",
+    lens: "Security and risk analysis",
+    focusAreas: [
+      "Attack surfaces \u2014 what can be exploited externally or internally?",
+      "Trust boundaries \u2014 where are credentials, data, or permissions crossing lines?",
+      "Failure modes \u2014 what happens when this breaks under adversarial conditions?",
+      "Blast radius \u2014 what is the worst-case scope of a breach or failure?"
+    ]
+  },
+  "end-user": {
+    label: "End User",
+    lens: "Real user perspective",
+    focusAreas: [
+      "Real needs vs stated needs \u2014 what does the user actually want vs what they said?",
+      "Adoption friction \u2014 what will cause users to abandon this in the first week?",
+      "Actual behavior \u2014 what do users do vs what you think they will do?",
+      "Comprehension gaps \u2014 what will users misunderstand or misuse?"
+    ]
+  },
+  "regulator": {
+    label: "Regulator",
+    lens: "Compliance and legal exposure",
+    focusAreas: [
+      "Regulatory exposure \u2014 what laws, rules, or frameworks apply and are being ignored?",
+      "Liability \u2014 who bears legal responsibility when this causes harm?",
+      "Stakeholder harm \u2014 who could be injured, defrauded, or discriminated against?",
+      "Unintended consequences \u2014 what second-order effects could trigger enforcement action?"
+    ]
+  },
+  "contrarian": {
+    label: "Contrarian",
+    lens: "Pure intellectual opposition",
+    focusAreas: [
+      "Historical failures \u2014 name similar ideas that failed and why this is the same.",
+      "Second-order effects \u2014 what happens after the first-order success plays out?",
+      "Inverted premise \u2014 what if the opposite assumption is actually correct?",
+      "Consensus trap \u2014 why might the conventional wisdom here be exactly wrong?"
+    ]
+  }
+};
+function buildPersonaChallengerPrompt(persona, intensity) {
+  const def = PERSONAS[persona];
+  if (!def) return buildChallengerPrompt(intensity);
+  const focusList = def.focusAreas.map((area, i) => `${i + 1}. ${area}`).join("\n");
+  const basePrompt = buildChallengerPrompt(intensity);
+  return `You are applying the lens of a ${def.label} (${def.lens}).
+
+Your specific focus areas for this lens:
+${focusList}
+
+Apply this lens rigorously throughout your response. Every critique must flow from this professional perspective.
+
+---
+
+${basePrompt}`;
+}
+function isValidPersona(name) {
+  return name in PERSONAS;
+}
+
+// src/engine/judge.ts
+function buildJudgeSystemPrompt() {
+  return `You are a neutral synthesis judge evaluating two AI responses to the same question.
+
+Your output MUST follow this exact structure:
+
+AGREEMENT: <number>%
+<One sentence explaining what drives the score \u2014 where they converge or diverge>
+
+SYNTHESIS
+<The actual synthesized recommendation \u2014 the verdict after weighing both responses. Be concrete and actionable.>
+
+BLIND SPOT
+<What both models missed or assumed without questioning. Be specific \u2014 name the assumption or gap.>
+
+Scoring guide for AGREEMENT:
+- 90\u2013100%: Substantively identical conclusions, only stylistic differences
+- 70\u201389%: Same core answer, meaningful differences in emphasis or caveats
+- 50\u201369%: Partial overlap, notable disagreement on key points
+- 30\u201349%: Different conclusions but some shared premises
+- 0\u201329%: Fundamentally opposed positions
+
+Be direct and critical. Do not praise either response.`;
+}
+function buildJudgeMessages(question, originalText, challengerText) {
+  return [
+    {
+      role: "user",
+      content: `QUESTION
+${question}
+
+---
+
+RESPONSE A (Original)
+${originalText}
+
+---
+
+RESPONSE B (Challenger)
+${challengerText}
+
+---
+
+Provide your synthesis following the required format exactly.`
+    }
+  ];
+}
+function extractAgreementScore(text) {
+  const match = /AGREEMENT:\s*(-?\d+)%/i.exec(text);
+  if (!match) return void 0;
+  const n = parseInt(match[1], 10);
+  if (isNaN(n)) return void 0;
+  return Math.max(0, Math.min(100, n));
+}
+
+// src/engine/mirror-engine.ts
+var MirrorEngine = class {
+  original;
+  challenger;
+  intensity;
+  autoClassify;
+  classifier;
+  debug;
+  judge;
+  persona;
+  constructor(options) {
+    this.original = options.original;
+    this.challenger = options.challenger;
+    this.intensity = options.intensity;
+    this.autoClassify = options.autoClassify;
+    this.classifier = options.classifier;
+    this.debug = options.debug ?? false;
+    this.judge = options.judge;
+    this.persona = options.persona;
+  }
+  async *run(userInput, history2, options) {
+    try {
+      if (this.autoClassify) {
+        yield { type: "classifying" };
+        let result;
+        try {
+          result = await this.classifier.classify(userInput);
+        } catch (error) {
+          this.log(`Classifier error: ${error.message}`);
+          result = {
+            category: "analysis",
+            shouldMirror: true,
+            confidence: 0,
+            reason: "Classifier error; defaulting to mirror."
+          };
+        }
+        yield { type: "classified", result };
+        if (!result.shouldMirror || !this.challenger) {
+          this.log("Classifier chose direct path.");
+          yield* this.runSingle(userInput, history2, options);
+          return;
+        }
+      }
+      if (!this.challenger) {
+        yield* this.runSingle(userInput, history2, options);
+        return;
+      }
+      yield* this.runMirror(userInput, history2, options);
+    } catch (error) {
+      yield { type: "error", error };
+    }
+  }
+  async *runSingle(userInput, history2, options) {
+    const messages = [...history2, { role: "user", content: userInput }];
+    const systemPrompt = buildOriginalPrompt();
+    const stream = this.streamWithRetry(
+      this.original,
+      messages,
+      systemPrompt,
+      options
+    );
+    const accumulator = createAccumulator();
+    for await (const chunk of stream) {
+      accumulator.add(chunk);
+      yield { type: "stream_chunk", brainId: this.original.id, chunk };
+    }
+    const response = accumulator.complete();
+    yield { type: "brain_complete", brainId: this.original.id, response };
+    yield { type: "all_complete" };
+  }
+  async *runMirror(userInput, history2, options) {
+    const originalMessages = [...history2, { role: "user", content: userInput }];
+    const challengerHistory = history2.map(
+      (message) => message.role === "assistant" ? {
+        ...message,
+        content: `[PREVIOUS ORIGINAL RESPONSE]
+${message.content}`
+      } : message
+    );
+    const challengerMessages = [
+      ...challengerHistory,
+      { role: "user", content: userInput }
+    ];
+    const originalPrompt = buildOriginalPrompt();
+    const challengerPrompt = this.persona && isValidPersona(this.persona) ? buildPersonaChallengerPrompt(this.persona, this.intensity) : buildChallengerPrompt(this.intensity);
+    const originalStream = this.streamWithRetry(
+      this.original,
+      originalMessages,
+      originalPrompt,
+      options
+    );
+    const challengerStream = this.streamWithRetry(
+      this.challenger,
+      challengerMessages,
+      challengerPrompt,
+      options
+    );
+    const originalAccumulator = createAccumulator();
+    const challengerAccumulator = createAccumulator();
+    for await (const item of mergeStreams([
+      { brainId: this.original.id, stream: originalStream, accumulator: originalAccumulator },
+      {
+        brainId: this.challenger.id,
+        stream: challengerStream,
+        accumulator: challengerAccumulator
+      }
+    ])) {
+      yield item;
+    }
+    const originalResponse = originalAccumulator.complete();
+    const challengerResponse = challengerAccumulator.complete();
+    yield {
+      type: "brain_complete",
+      brainId: this.original.id,
+      response: originalResponse
+    };
+    yield {
+      type: "brain_complete",
+      brainId: this.challenger.id,
+      response: challengerResponse
+    };
+    if (this.judge) {
+      yield* this.runJudge(userInput, originalResponse.text, challengerResponse.text, options);
+    }
+    yield { type: "all_complete" };
+  }
+  async *runJudge(question, originalText, challengerText, options) {
+    yield { type: "synthesizing" };
+    const messages = buildJudgeMessages(question, originalText, challengerText);
+    const systemPrompt = buildJudgeSystemPrompt();
+    const stream = this.streamWithRetry(this.judge, messages, systemPrompt, options);
+    const accumulator = createAccumulator();
+    for await (const chunk of stream) {
+      accumulator.add(chunk);
+      yield { type: "synthesis_chunk", chunk };
+    }
+    const response = accumulator.complete();
+    const agreementScore = extractAgreementScore(response.text);
+    const result = {
+      text: response.text,
+      agreementScore,
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens
+    };
+    yield { type: "synthesis_complete", result };
+  }
+  async *streamWithRetry(adapter, messages, systemPrompt, options, retries = 1) {
+    let attempt = 0;
+    while (true) {
+      try {
+        if (attempt > 0) {
+          this.log(`Retrying ${adapter.id} (attempt ${attempt + 1}).`);
+        }
+        const stream = adapter.chat(messages, systemPrompt, options);
+        for await (const chunk of stream) {
+          yield chunk;
+        }
+        return { text: "" };
+      } catch (error) {
+        if (attempt >= retries) {
+          throw error;
+        }
+        attempt += 1;
+        await delay(300 * attempt);
+      }
+    }
+  }
+  log(message) {
+    if (!this.debug) {
+      return;
+    }
+    process.stderr.write(`[debug] ${message}
+`);
+  }
+};
+function createAccumulator() {
+  let text = "";
+  let inputTokens;
+  let outputTokens;
+  return {
+    add(chunk) {
+      if (chunk.delta) {
+        text += chunk.delta;
+      }
+      if (chunk.inputTokens !== void 0) {
+        inputTokens = chunk.inputTokens;
+      }
+      if (chunk.outputTokens !== void 0) {
+        outputTokens = chunk.outputTokens;
+      }
+    },
+    complete() {
+      return { text, inputTokens, outputTokens };
+    }
+  };
+}
+async function* mergeStreams(entries) {
+  const pending = entries.map((entry) => ({
+    entry,
+    next: entry.stream.next()
+  }));
+  while (pending.length > 0) {
+    const race = pending.map(
+      (item, index2) => item.next.then((result2) => ({ index: index2, result: result2 }))
+    );
+    const { index, result } = await Promise.race(race);
+    const current = pending[index];
+    if (result.done) {
+      pending.splice(index, 1);
+      continue;
+    }
+    current.entry.accumulator.add(result.value);
+    yield {
+      type: "stream_chunk",
+      brainId: current.entry.brainId,
+      chunk: result.value
+    };
+    current.next = current.entry.stream.next();
+  }
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/engine/session.ts
+var Session = class {
+  maxHistory;
+  messages = [];
+  constructor(maxHistory = 20) {
+    this.maxHistory = maxHistory;
+  }
+  addUser(content) {
+    this.push({ role: "user", content });
+  }
+  addAssistant(content) {
+    this.push({ role: "assistant", content });
+  }
+  getHistory() {
+    return [...this.messages];
+  }
+  clear() {
+    this.messages.length = 0;
+  }
+  push(message) {
+    this.messages.push(message);
+    while (this.messages.length > this.maxHistory) {
+      this.messages.splice(0, 2);
+    }
+  }
+};
+
+// src/ui/mirror-app.tsx
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box as Box2, Static, Text as Text4, useInput, useStdout } from "ink";
+
+// src/history/store.ts
+import Conf2 from "conf";
+var store2 = new Conf2({
+  projectName: "adversarial-mirror",
+  configName: "history",
+  defaults: { entries: [] }
+});
+var MAX_ENTRIES = 200;
+function addHistoryEntry(entry) {
+  const entries = store2.store.entries ?? [];
+  const next = [entry, ...entries];
+  if (next.length > MAX_ENTRIES) {
+    next.length = MAX_ENTRIES;
+  }
+  store2.store = { entries: next };
+}
+function listHistory() {
+  return store2.store.entries ?? [];
+}
+function getHistory(id) {
+  return (store2.store.entries ?? []).find((entry) => entry.id === id);
+}
+
+// src/ui/components/BrainPanel.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function BrainPanel({
+  title,
+  children,
+  width,
+  marginRight,
+  borderColor = "cyan"
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      padding: 1,
+      flexGrow: width ? 0 : 1,
+      flexShrink: 1,
+      minWidth: 0,
+      width,
+      marginRight,
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: borderColor, children: title }),
+        children
+      ]
+    }
+  );
+}
+
+// src/ui/components/IntentBadge.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function IntentBadge({ category, mirrored }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { backgroundColor: mirrored ? "blue" : "blackBright", color: "white", children: ` ${mirrored ? "MIRRORING" : "DIRECT"} ` }),
+    /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+      " ",
+      category
+    ] })
+  ] });
+}
+
+// src/ui/components/StreamingText.tsx
+import { Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function StreamingText({ value, dim }) {
+  return /* @__PURE__ */ jsxs3(Text3, { dimColor: dim, wrap: "wrap", children: [
+    value,
+    /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u258C" })
+  ] });
+}
+
+// src/ui/utils/highlight.ts
+import { highlight } from "cli-highlight";
+function highlightCodeBlocks(text) {
+  if (!text.includes("```")) {
+    return text;
+  }
+  const fenceRegex = /```(\w+)?\n([\s\S]*?)```/g;
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = fenceRegex.exec(text)) !== null) {
+    const [block, lang, code] = match;
+    result += text.slice(lastIndex, match.index);
+    try {
+      const highlighted = highlight(code, {
+        language: lang || void 0,
+        ignoreIllegals: true
+      });
+      result += `
+${highlighted}
+`;
+    } catch {
+      result += `
+${code}
+`;
+    }
+    lastIndex = match.index + block.length;
+  }
+  result += text.slice(lastIndex);
+  return result;
+}
+
+// src/ui/mirror-app.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var GRAD = ["#00D2FF", "#3A7BD5", "#7F5AF0", "#FF6EC7", "#FFB86C"];
+function hexToRgb(hex) {
+  const n = hex.replace("#", "");
+  const v = parseInt(n.length === 3 ? n.split("").map((c) => c + c).join("") : n, 16);
+  return { r: v >> 16 & 255, g: v >> 8 & 255, b: v & 255 };
+}
+function gradColor(pos) {
+  const p = Math.max(0, Math.min(1, pos));
+  const steps = GRAD.length - 1;
+  const scaled = p * steps;
+  const i = Math.min(Math.floor(scaled), steps - 1);
+  const t = scaled - i;
+  const a = hexToRgb(GRAD[i]);
+  const b = hexToRgb(GRAD[i + 1]);
+  const r = Math.round(a.r + (b.r - a.r) * t);
+  const g = Math.round(a.g + (b.g - a.g) * t);
+  const bv = Math.round(a.b + (b.b - a.b) * t);
+  return `#${[r, g, bv].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+function GradientLine({ line, bold }) {
+  if (!line.trim()) return /* @__PURE__ */ jsx4(Text4, { children: " " });
+  const chars = Array.from(line);
+  const last = Math.max(chars.length - 1, 1);
+  return /* @__PURE__ */ jsx4(Text4, { bold, wrap: "truncate", children: chars.map((ch, idx) => /* @__PURE__ */ jsx4(Text4, { color: gradColor(idx / last), children: ch }, idx)) });
+}
+var HeaderView = React.memo(function HeaderView2({
+  lines,
+  originalId,
+  challengerId,
+  intensity
+}) {
+  return /* @__PURE__ */ jsxs4(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    lines.map((line, i) => /* @__PURE__ */ jsx4(GradientLine, { line, bold: true }, i)),
+    /* @__PURE__ */ jsxs4(Text4, { color: "gray", dimColor: true, children: [
+      "  ",
+      originalId,
+      challengerId ? ` vs ${challengerId}` : "  [direct mode]",
+      "  ",
+      "[",
+      intensity,
+      "]"
+    ] })
+  ] });
+});
+function stripAgreementHeader(text) {
+  return text.replace(/^AGREEMENT:\s*-?\d+%[^\n]*\n?\n?/i, "").trimStart();
+}
+var ExchangeView = React.memo(function ExchangeView2({
+  exchange,
+  originalId,
+  challengerId,
+  columns
+}) {
+  const sideBySide = exchange.isMirrored && Boolean(exchange.challenger) && columns >= 80;
+  const panelWidth = sideBySide ? Math.floor((columns - 1) / 2) : columns;
+  const scoreLabel = exchange.agreementScore !== void 0 ? `  [agreement: ${exchange.agreementScore}%]` : "";
+  return /* @__PURE__ */ jsxs4(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "You: " }),
+      /* @__PURE__ */ jsx4(Text4, { children: exchange.question })
+    ] }),
+    exchange.intent && /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx4(IntentBadge, { category: exchange.intent.category, mirrored: exchange.intent.shouldMirror }),
+      /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+        " ",
+        Math.round(exchange.intent.confidence * 100),
+        "%"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box2, { marginTop: 1, flexDirection: sideBySide ? "row" : "column", children: [
+      /* @__PURE__ */ jsx4(
+        BrainPanel,
+        {
+          title: `ORIGINAL  ${originalId}`,
+          width: panelWidth,
+          marginRight: sideBySide ? 1 : 0,
+          children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: exchange.original })
+        }
+      ),
+      exchange.isMirrored && exchange.challenger && /* @__PURE__ */ jsx4(
+        BrainPanel,
+        {
+          title: `CHALLENGER  ${challengerId}`,
+          width: panelWidth,
+          children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: exchange.challenger })
+        }
+      )
+    ] }),
+    exchange.synthesis && /* @__PURE__ */ jsx4(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx4(
+      BrainPanel,
+      {
+        title: `SYNTHESIS${scoreLabel}`,
+        width: columns,
+        borderColor: "yellow",
+        children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: stripAgreementHeader(exchange.synthesis) })
+      }
+    ) })
+  ] });
+});
+function loadRawHeaderLines() {
+  const cwd = process.cwd();
+  const candidates = [
+    resolve(cwd, "src", "ui", "header.txt"),
+    resolve(cwd, "header.txt")
+  ];
+  for (const f of candidates) {
+    if (!existsSync(f)) continue;
+    try {
+      const lines = readFileSync(f, "utf8").split(/\r?\n/);
+      while (lines.length > 0 && !lines[lines.length - 1].trim()) lines.pop();
+      return lines;
+    } catch {
+      continue;
+    }
+  }
+  try {
+    const p = fileURLToPath(new URL("./header.txt", import.meta.url));
+    if (existsSync(p)) {
+      const lines = readFileSync(p, "utf8").split(/\r?\n/);
+      while (lines.length > 0 && !lines[lines.length - 1].trim()) lines.pop();
+      return lines;
+    }
+  } catch {
+  }
+  return [];
+}
+function fitLines(lines, cols) {
+  if (!lines.length || cols <= 0) return [];
+  const trimmed = lines.map((l) => l.replace(/\s+$/, ""));
+  const nonEmpty = trimmed.filter((l) => l.trim().length > 0);
+  const indent = nonEmpty.length ? Math.min(...nonEmpty.map((l) => l.match(/^\s*/)?.[0].length ?? 0)) : 0;
+  const aligned = indent > 0 ? trimmed.map((l) => l.slice(indent)) : trimmed;
+  return aligned.map((l) => l.length > cols ? l.slice(0, cols) : l);
+}
+function tailLines(text, maxLines) {
+  if (maxLines <= 0) return "";
+  const lines = text.split(/\r?\n/);
+  if (lines.length <= maxLines) return text;
+  return lines.slice(-maxLines).join("\n");
+}
+function formatTokens(input3, output3) {
+  if (input3 === void 0 && output3 === void 0) return null;
+  return `${input3 ?? 0}/${output3 ?? 0}tok`;
+}
+function MirrorApp({
+  engine,
+  session,
+  originalId,
+  challengerId,
+  judgerId,
+  intensity,
+  showTokenCounts = false,
+  showLatency = true,
+  syntaxHighlighting = true
+}) {
+  const { stdout } = useStdout();
+  const columns = stdout?.columns ?? 120;
+  const rows = stdout?.rows ?? 40;
+  const headerLines = useMemo(() => {
+    const raw = loadRawHeaderLines();
+    return fitLines(raw, Math.max(1, columns - 1));
+  }, []);
+  const [staticItems, setStaticItems] = useState([
+    { type: "header", id: "header" }
+  ]);
+  const [input3, setInput] = useState("");
+  const [activeQuestion, setActiveQuestion] = useState("");
+  const [currentOriginal, setCurrentOriginal] = useState("");
+  const [currentChallenger, setCurrentChallenger] = useState("");
+  const [currentSynthesis, setCurrentSynthesis] = useState("");
+  const [isThinking, setIsThinking] = useState(false);
+  const [isClassifying, setIsClassifying] = useState(false);
+  const [isSynthesizing, setIsSynthesizing] = useState(false);
+  const [intent, setIntent] = useState(null);
+  const [error, setError] = useState(null);
+  const [originalStats, setOriginalStats] = useState(null);
+  const [challengerStats, setChallengerStats] = useState(null);
+  const [synthesisStats, setSynthesisStats] = useState(null);
+  const [turnCount, setTurnCount] = useState(0);
+  const [commitTick, setCommitTick] = useState(0);
+  const runningRef = useRef(false);
+  const abortRef = useRef(null);
+  const pendingOrigRef = useRef("");
+  const pendingChalRef = useRef("");
+  const pendingSynthRef = useRef("");
+  const pendingExchangeRef = useRef(null);
+  const startTimesRef = useRef(/* @__PURE__ */ new Map());
+  const columnsRef = useRef(columns);
+  useEffect(() => {
+    columnsRef.current = columns;
+  }, [columns]);
+  useEffect(() => {
+    if (isThinking) return;
+    if (!pendingExchangeRef.current) return;
+    setCommitTick((tick) => tick + 1);
+  }, [isThinking]);
+  useEffect(() => {
+    if (!pendingExchangeRef.current) return;
+    const item = pendingExchangeRef.current;
+    pendingExchangeRef.current = null;
+    setStaticItems((prev) => [...prev, item]);
+  }, [commitTick]);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setCurrentOriginal(pendingOrigRef.current);
+      setCurrentChallenger(pendingChalRef.current);
+      setCurrentSynthesis(pendingSynthRef.current);
+    }, 60);
+    return () => clearInterval(id);
+  }, []);
+  const showChallengerPanel = Boolean(challengerId) && (intent?.shouldMirror ?? true);
+  const showSideBySide = showChallengerPanel && columns >= 80;
+  const panelWidth = showSideBySide ? Math.floor((columns - 1) / 2) : columns;
+  const liveLineLimit = Math.max(6, Math.min(18, rows - 10));
+  const formatText = useCallback(
+    (text) => syntaxHighlighting ? highlightCodeBlocks(text) : text,
+    [syntaxHighlighting]
+  );
+  const submit = useCallback(async () => {
+    if (runningRef.current) return;
+    const question = input3.trim();
+    if (!question) return;
+    runningRef.current = true;
+    setInput("");
+    setError(null);
+    setIntent(null);
+    setActiveQuestion(question);
+    setIsThinking(true);
+    setIsClassifying(false);
+    setIsSynthesizing(false);
+    setOriginalStats(null);
+    setChallengerStats(null);
+    setSynthesisStats(null);
+    pendingOrigRef.current = "";
+    pendingChalRef.current = "";
+    pendingSynthRef.current = "";
+    setCurrentOriginal("");
+    setCurrentChallenger("");
+    setCurrentSynthesis("");
+    const history2 = session.getHistory();
+    session.addUser(question);
+    let originalBuffer = "";
+    let challengerBuffer = "";
+    let synthesisBuffer = "";
+    let originalResult = null;
+    let challengerResult;
+    let synthResult;
+    let intentResult;
+    let isMirrored = Boolean(challengerId);
+    const entryId = randomUUID();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    startTimesRef.current = new Map([
+      [originalId, Date.now()],
+      ...challengerId ? [[challengerId, Date.now()]] : []
+    ]);
+    try {
+      for await (const event of engine.run(question, history2, { signal: controller.signal })) {
+        if (event.type === "classifying") {
+          setIsClassifying(true);
+        }
+        if (event.type === "classified") {
+          setIsClassifying(false);
+          setIntent(event.result);
+          intentResult = event.result;
+          isMirrored = event.result.shouldMirror && Boolean(challengerId);
+        }
+        if (event.type === "stream_chunk") {
+          if (event.brainId === originalId) {
+            originalBuffer += event.chunk.delta;
+            pendingOrigRef.current = originalBuffer;
+          } else if (event.brainId === challengerId) {
+            challengerBuffer += event.chunk.delta;
+            pendingChalRef.current = challengerBuffer;
+          }
+        }
+        if (event.type === "brain_complete") {
+          const latency = Date.now() - (startTimesRef.current.get(event.brainId) ?? Date.now());
+          if (event.brainId === originalId) {
+            const text = event.response.text || originalBuffer;
+            originalResult = {
+              brainId: originalId,
+              text,
+              inputTokens: event.response.inputTokens,
+              outputTokens: event.response.outputTokens,
+              latencyMs: latency
+            };
+            setOriginalStats(originalResult);
+            session.addAssistant(text);
+          } else if (event.brainId === challengerId) {
+            const text = event.response.text || challengerBuffer;
+            challengerResult = {
+              brainId: challengerId,
+              text,
+              inputTokens: event.response.inputTokens,
+              outputTokens: event.response.outputTokens,
+              latencyMs: latency
+            };
+            setChallengerStats(challengerResult);
+          }
+        }
+        if (event.type === "synthesizing") {
+          setIsSynthesizing(true);
+        }
+        if (event.type === "synthesis_chunk") {
+          synthesisBuffer += event.chunk.delta;
+          pendingSynthRef.current = synthesisBuffer;
+        }
+        if (event.type === "synthesis_complete") {
+          setIsSynthesizing(false);
+          synthResult = event.result;
+          setSynthesisStats(event.result);
+        }
+        if (event.type === "all_complete" && originalResult) {
+          addHistoryEntry({
+            id: entryId,
+            createdAt,
+            question,
+            original: originalResult,
+            challenger: challengerResult,
+            intent: intentResult
+          });
+          const exchange = {
+            id: entryId,
+            question,
+            intent: intentResult,
+            original: formatText(originalResult.text),
+            challenger: challengerResult ? formatText(challengerResult.text) : void 0,
+            synthesis: synthResult ? formatText(synthResult.text) : void 0,
+            agreementScore: synthResult?.agreementScore,
+            isMirrored
+          };
+          pendingExchangeRef.current = {
+            type: "exchange",
+            id: entryId,
+            exchange,
+            originalId,
+            challengerId,
+            columns: columnsRef.current
+          };
+          setTurnCount((prev) => prev + 1);
+          setActiveQuestion("");
+          pendingOrigRef.current = "";
+          pendingChalRef.current = "";
+          pendingSynthRef.current = "";
+          setCurrentOriginal("");
+          setCurrentChallenger("");
+          setCurrentSynthesis("");
+          setIsSynthesizing(false);
+          setIsClassifying(false);
+        }
+        if (event.type === "error") {
+          setError(event.error.message);
+        }
+      }
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        setError(err.message ?? "Unknown error");
+      }
+    } finally {
+      setIsThinking(false);
+      setIsClassifying(false);
+      setIsSynthesizing(false);
+      runningRef.current = false;
+      abortRef.current = null;
+    }
+  }, [challengerId, engine, formatText, input3, originalId, session]);
+  useInput((ch, key) => {
+    if (key.ctrl && ch === "c") {
+      if (isThinking && abortRef.current) {
+        abortRef.current.abort();
+        return;
+      }
+      process.exit(0);
+    }
+    if (key.return) {
+      void submit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((p) => p.slice(0, -1));
+      return;
+    }
+    if (ch && !key.ctrl && !key.meta) setInput((p) => p + ch);
+  });
+  const statusParts = [];
+  if (isClassifying) statusParts.push("Classifying...");
+  else if (isSynthesizing) statusParts.push("Synthesizing...");
+  else if (isThinking) statusParts.push("Thinking...");
+  else statusParts.push("Ready");
+  if (showTokenCounts) {
+    const origT = formatTokens(originalStats?.inputTokens, originalStats?.outputTokens);
+    if (origT) statusParts.push(`orig ${origT}`);
+    if (challengerStats) {
+      const chalT = formatTokens(challengerStats.inputTokens, challengerStats.outputTokens);
+      if (chalT) statusParts.push(`chal ${chalT}`);
+    }
+    if (synthesisStats) {
+      const synthT = formatTokens(synthesisStats.inputTokens, synthesisStats.outputTokens);
+      if (synthT) statusParts.push(`synth ${synthT}`);
+    }
+  }
+  if (showLatency && originalStats?.latencyMs != null) {
+    statusParts.push(`orig ${(originalStats.latencyMs / 1e3).toFixed(1)}s`);
+  }
+  if (showLatency && challengerStats?.latencyMs != null) {
+    statusParts.push(`chal ${(challengerStats.latencyMs / 1e3).toFixed(1)}s`);
+  }
+  if (synthesisStats?.agreementScore !== void 0) {
+    statusParts.push(`agreement ${synthesisStats.agreementScore}%`);
+  }
+  statusParts.push(`${turnCount} turn${turnCount !== 1 ? "s" : ""}`);
+  statusParts.push("Ctrl+C to exit");
+  const synthScoreLabel = synthesisStats?.agreementScore !== void 0 ? `  [agreement: ${synthesisStats.agreementScore}%]` : "";
+  return /* @__PURE__ */ jsxs4(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Static, { items: staticItems, children: (item) => /* @__PURE__ */ jsx4(React.Fragment, { children: item.type === "header" ? /* @__PURE__ */ jsx4(
+      HeaderView,
+      {
+        lines: headerLines,
+        originalId,
+        challengerId,
+        intensity
+      }
+    ) : /* @__PURE__ */ jsx4(
+      ExchangeView,
+      {
+        exchange: item.exchange,
+        originalId: item.originalId,
+        challengerId: item.challengerId,
+        columns: item.columns
+      }
+    ) }, item.id) }),
+    isThinking && activeQuestion && /* @__PURE__ */ jsxs4(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { bold: true, children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "You: " }),
+        /* @__PURE__ */ jsx4(Text4, { children: activeQuestion })
+      ] }),
+      intent ? /* @__PURE__ */ jsxs4(Box2, { children: [
+        /* @__PURE__ */ jsx4(IntentBadge, { category: intent.category, mirrored: intent.shouldMirror }),
+        /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+          " ",
+          Math.round(intent.confidence * 100),
+          "%"
+        ] })
+      ] }) : isClassifying ? /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "Classifying..." }) : null,
+      /* @__PURE__ */ jsxs4(Box2, { marginTop: 1, flexDirection: showSideBySide ? "row" : "column", children: [
+        /* @__PURE__ */ jsx4(
+          BrainPanel,
+          {
+            title: `ORIGINAL  ${originalId}`,
+            width: panelWidth,
+            marginRight: showSideBySide && showChallengerPanel ? 1 : 0,
+            children: /* @__PURE__ */ jsx4(StreamingText, { value: tailLines(currentOriginal, liveLineLimit) })
+          }
+        ),
+        showChallengerPanel && /* @__PURE__ */ jsx4(
+          BrainPanel,
+          {
+            title: `CHALLENGER  ${challengerId}  [${intensity}]`,
+            width: panelWidth,
+            children: /* @__PURE__ */ jsx4(StreamingText, { value: tailLines(currentChallenger, liveLineLimit) })
+          }
+        )
+      ] }),
+      (isSynthesizing || currentSynthesis) && /* @__PURE__ */ jsx4(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx4(
+        BrainPanel,
+        {
+          title: `SYNTHESIS${isSynthesizing ? "  synthesizing..." : synthScoreLabel}  ${judgerId ?? ""}`,
+          width: columns,
+          borderColor: "yellow",
+          children: /* @__PURE__ */ jsx4(StreamingText, { value: tailLines(stripAgreementHeader(currentSynthesis), liveLineLimit) })
+        }
+      ) })
+    ] }),
+    error && /* @__PURE__ */ jsx4(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) }),
+    /* @__PURE__ */ jsx4(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: statusParts.join(" \xB7 ") }) }),
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx4(Text4, { children: input3 }),
+      /* @__PURE__ */ jsx4(Text4, { color: isThinking ? "gray" : "cyan", children: "\u2588" })
+    ] })
+  ] });
+}
+
+// src/cli/commands/chat.ts
+function runChat(_localOpts, command) {
+  const parentOpts = command.parent?.opts() ?? {};
+  const localOpts = command.opts();
+  const opts = { ...parentOpts, ...localOpts };
+  try {
+    const config2 = loadConfig();
+    const originalId = opts["original"] ?? config2.session.originalBrainId;
+    const challengerId = opts["challenger"] ?? config2.session.challengerBrainId;
+    const mirrorEnabled = opts["mirror"] !== false;
+    const classifyEnabled = opts["classify"] !== false;
+    const intensity = opts["intensity"] ?? config2.session.defaultIntensity;
+    const judgeEnabled = opts["judge"] !== false && config2.session.judgeEnabled;
+    const persona = opts["persona"] ?? config2.session.defaultPersona;
+    const filePath = opts["file"];
+    const brainConfig = config2.brains.find((b) => b.id === originalId);
+    if (!brainConfig) {
+      throw new Error(`Original brain not found: ${originalId}`);
+    }
+    const originalAdapter = createAdapter(brainConfig);
+    const challengerConfig = config2.brains.find((b) => b.id === challengerId);
+    const challengerAdapter = mirrorEnabled && challengerConfig ? createAdapter(challengerConfig) : void 0;
+    let judgeAdapter = void 0;
+    if (mirrorEnabled && challengerAdapter && judgeEnabled) {
+      const judgeId = opts["judgeBrain"] ?? config2.session.judgeBrainId;
+      const judgeConfig = config2.brains.find((b) => b.id === judgeId);
+      if (judgeConfig) {
+        judgeAdapter = createAdapter(judgeConfig);
+      }
+    }
+    const session = new Session(config2.session.historyWindowSize);
+    if (filePath) {
+      try {
+        const content = readFileSync2(filePath, "utf8");
+        const name = basename(filePath);
+        session.addUser(`[FILE: ${name}]
+${content}`);
+        session.addAssistant(`I have read the file "${name}". Ask me anything about it.`);
+      } catch (err) {
+        throw new Error(`Could not read file: ${filePath} \u2014 ${err.message}`);
+      }
+    }
+    const classifier = buildIntentClassifier(config2, Boolean(opts["debug"]));
+    const engine = new MirrorEngine({
+      original: originalAdapter,
+      challenger: challengerAdapter,
+      intensity,
+      autoClassify: mirrorEnabled && classifyEnabled && config2.session.autoClassify,
+      classifier,
+      debug: Boolean(opts["debug"]),
+      judge: judgeAdapter,
+      persona
+    });
+    const app = render(
+      React2.createElement(MirrorApp, {
+        engine,
+        session,
+        originalId: originalAdapter.id,
+        challengerId: challengerAdapter?.id,
+        judgerId: judgeAdapter?.id,
+        intensity,
+        layout: config2.ui.layout,
+        showTokenCounts: config2.ui.showTokenCounts,
+        showLatency: config2.ui.showLatency,
+        syntaxHighlighting: config2.ui.syntaxHighlighting
+      })
+    );
+    void app.waitUntilExit();
+  } catch (error) {
+    process.stderr.write(`Failed to start chat: ${error.message}
+`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/mirror.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+import { basename as basename2 } from "path";
+function readStdin() {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+async function runMirror(question, _localOpts, command) {
+  const parentOpts = command.parent?.opts() ?? {};
+  const localOpts = command.opts();
+  const opts = { ...parentOpts, ...localOpts };
+  try {
+    const config2 = loadConfig();
+    const originalId = opts["original"] ?? config2.session.originalBrainId;
+    const challengerId = opts["challenger"] ?? config2.session.challengerBrainId;
+    const intensity = opts["intensity"] ?? config2.session.defaultIntensity;
+    const mirrorEnabled = opts["mirror"] !== false;
+    const classifyEnabled = opts["classify"] !== false;
+    const judgeEnabled = opts["judge"] !== false && config2.session.judgeEnabled;
+    const persona = opts["persona"] ?? config2.session.defaultPersona;
+    const filePath = opts["file"];
+    let filePrefix = "";
+    if (filePath) {
+      try {
+        const content = readFileSync3(filePath, "utf8");
+        const name = basename2(filePath);
+        filePrefix = `[FILE: ${name}]
+${content}
+
+---
+`;
+      } catch (err) {
+        throw new Error(`Could not read file: ${filePath} \u2014 ${err.message}`);
+      }
+    } else if (!process.stdin.isTTY) {
+      const content = await readStdin();
+      if (content.trim()) {
+        filePrefix = `[STDIN]
+${content}
+
+---
+`;
+      }
+    }
+    const fullQuestion = filePrefix ? `${filePrefix}${question}` : question;
+    const originalConfig = config2.brains.find((b) => b.id === originalId);
+    if (!originalConfig) throw new Error(`Original brain not found: ${originalId}`);
+    const originalAdapter = createAdapter(originalConfig);
+    const challengerConfig = config2.brains.find((b) => b.id === challengerId);
+    const challengerAdapter = mirrorEnabled && challengerConfig ? createAdapter(challengerConfig) : void 0;
+    let judgeAdapter = void 0;
+    if (mirrorEnabled && challengerAdapter && judgeEnabled) {
+      const judgeId = opts["judgeBrain"] ?? config2.session.judgeBrainId;
+      const judgeConfig = config2.brains.find((b) => b.id === judgeId);
+      if (judgeConfig) {
+        judgeAdapter = createAdapter(judgeConfig);
+      }
+    }
+    const classifier = buildIntentClassifier(config2, Boolean(opts["debug"]));
+    const engine = new MirrorEngine({
+      original: originalAdapter,
+      challenger: challengerAdapter,
+      intensity,
+      autoClassify: mirrorEnabled && classifyEnabled,
+      classifier,
+      debug: Boolean(opts["debug"]),
+      judge: judgeAdapter,
+      persona
+    });
+    const session = new Session(1);
+    const results = /* @__PURE__ */ new Map();
+    let intentResult;
+    const entryId = randomUUID2();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTimes = new Map([
+      [originalAdapter.id, Date.now()],
+      ...challengerAdapter ? [[challengerAdapter.id, Date.now()]] : []
+    ]);
+    let originalHeaderPrinted = false;
+    let synthBuffer = "";
+    let synthScore;
+    for await (const event of engine.run(fullQuestion, session.getHistory())) {
+      if (event.type === "classifying") {
+        process.stdout.write("Classifying...\n");
+      }
+      if (event.type === "classified") {
+        const label = event.result.shouldMirror ? "MIRRORING" : "DIRECT";
+        process.stdout.write(
+          `[${label}] ${event.result.category} (${Math.round(event.result.confidence * 100)}%)
+`
+        );
+        intentResult = event.result;
+      }
+      if (event.type === "stream_chunk" && !event.chunk.isFinal) {
+        if (event.brainId === originalAdapter.id) {
+          if (!originalHeaderPrinted) {
+            process.stdout.write(`
+ORIGINAL (${originalAdapter.id})
+`);
+            originalHeaderPrinted = true;
+          }
+          process.stdout.write(event.chunk.delta);
+        }
+      }
+      if (event.type === "brain_complete") {
+        const latency = Date.now() - (startTimes.get(event.brainId) ?? Date.now());
+        results.set(event.brainId, {
+          brainId: event.brainId,
+          text: event.response.text,
+          inputTokens: event.response.inputTokens,
+          outputTokens: event.response.outputTokens,
+          latencyMs: latency
+        });
+      }
+      if (event.type === "synthesizing") {
+        if (originalHeaderPrinted) process.stdout.write("\n");
+        if (challengerAdapter) {
+          const challengerResult = results.get(challengerAdapter.id);
+          process.stdout.write(`
+CHALLENGER (${challengerAdapter.id})
+`);
+          process.stdout.write(`${challengerResult?.text ?? ""}
+`);
+        }
+        process.stdout.write("\nSYNTHESIS (judge)\n");
+      }
+      if (event.type === "synthesis_chunk" && !event.chunk.isFinal) {
+        synthBuffer += event.chunk.delta;
+        process.stdout.write(event.chunk.delta);
+      }
+      if (event.type === "synthesis_complete") {
+        synthScore = event.result.agreementScore;
+        process.stdout.write("\n");
+        if (synthScore !== void 0) {
+          process.stdout.write(`
+Agreement score: ${synthScore}%
+`);
+        }
+      }
+      if (event.type === "all_complete") {
+        if (!judgeAdapter) {
+          if (originalHeaderPrinted) process.stdout.write("\n");
+          if (challengerAdapter) {
+            const challengerResult = results.get(challengerAdapter.id);
+            process.stdout.write(`
+CHALLENGER (${challengerAdapter.id})
+`);
+            process.stdout.write(`${challengerResult?.text ?? ""}
+`);
+          }
+        }
+      }
+      if (event.type === "error") throw event.error;
+    }
+    const originalResult = results.get(originalAdapter.id);
+    if (originalResult) {
+      addHistoryEntry({
+        id: entryId,
+        createdAt,
+        question: fullQuestion,
+        original: originalResult,
+        challenger: challengerAdapter ? results.get(challengerAdapter.id) : void 0,
+        intent: intentResult
+      });
+    }
+  } catch (error) {
+    process.stderr.write(`Failed to run mirror: ${error.message}
+`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/config.ts
+import { execFile } from "child_process";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function runConfigShow() {
+  const config2 = loadConfig();
+  process.stdout.write(JSON.stringify(config2, null, 2));
+  process.stdout.write("\n");
+}
+async function runConfigInit() {
+  const rl = createInterface({ input, output });
+  try {
+    const config2 = loadConfig();
+    if (config2.brains.length === 0) {
+      throw new Error("No brains configured. Run mirror brains add first.");
+    }
+    const intensity = await askRequired(
+      rl,
+      `Default intensity (mild|moderate|aggressive) [${config2.session.defaultIntensity}]: `,
+      config2.session.defaultIntensity
+    );
+    if (!["mild", "moderate", "aggressive"].includes(intensity)) {
+      throw new Error(`Invalid intensity: ${intensity}`);
+    }
+    const layout = await askRequired(
+      rl,
+      `Layout (side-by-side|stacked) [${config2.ui.layout}]: `,
+      config2.ui.layout
+    );
+    if (!["side-by-side", "stacked"].includes(layout)) {
+      throw new Error(`Invalid layout: ${layout}`);
+    }
+    const showTokenCounts = await askYesNo(
+      rl,
+      `Show token counts? (y/n) [${config2.ui.showTokenCounts ? "y" : "n"}]: `,
+      config2.ui.showTokenCounts
+    );
+    const showLatency = await askYesNo(
+      rl,
+      `Show latency? (y/n) [${config2.ui.showLatency ? "y" : "n"}]: `,
+      config2.ui.showLatency
+    );
+    const syntaxHighlighting = await askYesNo(
+      rl,
+      `Syntax highlighting? (y/n) [${config2.ui.syntaxHighlighting ? "y" : "n"}]: `,
+      config2.ui.syntaxHighlighting
+    );
+    const autoClassify = await askYesNo(
+      rl,
+      `Auto-classify intent? (y/n) [${config2.session.autoClassify ? "y" : "n"}]: `,
+      config2.session.autoClassify
+    );
+    const historyWindowSize = Number(
+      await askRequired(
+        rl,
+        `History window size [${config2.session.historyWindowSize}]: `,
+        String(config2.session.historyWindowSize)
+      )
+    );
+    if (!Number.isInteger(historyWindowSize) || historyWindowSize <= 0) {
+      throw new Error("History window size must be a positive integer.");
+    }
+    const availableBrains = config2.brains.map((brain) => brain.id).join(", ");
+    const originalBrainId = await askRequired(
+      rl,
+      `Original brain id (${availableBrains}) [${config2.session.originalBrainId}]: `,
+      config2.session.originalBrainId
+    );
+    const challengerBrainId = await askRequired(
+      rl,
+      `Challenger brain id (${availableBrains}) [${config2.session.challengerBrainId}]: `,
+      config2.session.challengerBrainId
+    );
+    if (!config2.brains.some((brain) => brain.id === originalBrainId)) {
+      throw new Error(`Unknown original brain id: ${originalBrainId}`);
+    }
+    if (!config2.brains.some((brain) => brain.id === challengerBrainId)) {
+      throw new Error(`Unknown challenger brain id: ${challengerBrainId}`);
+    }
+    const judgeEnabled = await askYesNo(
+      rl,
+      `Enable judge synthesis pass? (y/n) [${config2.session.judgeEnabled ? "y" : "n"}]: `,
+      config2.session.judgeEnabled
+    );
+    let judgeBrainId = config2.session.judgeBrainId;
+    if (judgeEnabled) {
+      judgeBrainId = await askRequired(
+        rl,
+        `Judge brain id (${availableBrains}) [${config2.session.judgeBrainId}]: `,
+        config2.session.judgeBrainId
+      );
+      if (!config2.brains.some((brain) => brain.id === judgeBrainId)) {
+        throw new Error(`Unknown judge brain id: ${judgeBrainId}`);
+      }
+    }
+    const personaNames = "vc-skeptic|security-auditor|end-user|regulator|contrarian";
+    const currentPersona = config2.session.defaultPersona ?? "none";
+    const personaAnswer = await askOptional(
+      rl,
+      `Default persona (${personaNames}|none) [${currentPersona}]: `,
+      currentPersona
+    );
+    const defaultPersona = personaAnswer === "none" || !personaAnswer ? void 0 : personaAnswer;
+    const updatedKeys = await promptForApiKeys(rl, config2);
+    if (Object.keys(updatedKeys).length > 0) {
+      const persist = await askYesNo(
+        rl,
+        "Persist API keys to environment variables? (y/n) [y]: ",
+        true
+      );
+      if (persist) {
+        await persistEnvVars(updatedKeys);
+        process.stdout.write(
+          "Keys saved. Open a new terminal session to pick them up.\n"
+        );
+      }
+    }
+    await validateGeminiModels(rl, config2, updatedKeys);
+    saveConfig({
+      ...config2,
+      session: {
+        ...config2.session,
+        originalBrainId,
+        challengerBrainId,
+        defaultIntensity: intensity,
+        historyWindowSize,
+        autoClassify,
+        judgeEnabled,
+        judgeBrainId,
+        defaultPersona
+      },
+      ui: {
+        ...config2.ui,
+        layout,
+        showTokenCounts,
+        showLatency,
+        syntaxHighlighting
+      }
+    });
+    process.stdout.write("Config saved.\n");
+  } catch (error) {
+    process.stderr.write(
+      `Failed to initialize config: ${error.message}
+`
+    );
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+function runConfigSet(key, value) {
+  try {
+    const parsed = parseValue(value);
+    const updated = setConfigValue(key, parsed);
+    process.stdout.write(JSON.stringify(updated, null, 2));
+    process.stdout.write("\n");
+  } catch (error) {
+    process.stderr.write(`Failed to set config: ${error.message}
+`);
+    process.exit(1);
+  }
+}
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return value;
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (!Number.isNaN(Number(trimmed))) return Number(trimmed);
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+async function askRequired(rl, prompt, fallback) {
+  const answer = (await rl.question(prompt)).trim();
+  if (answer) {
+    return answer;
+  }
+  if (fallback) {
+    return fallback;
+  }
+  return askRequired(rl, prompt, fallback);
+}
+async function askOptional(rl, prompt, fallback) {
+  const answer = (await rl.question(prompt)).trim();
+  return answer || fallback;
+}
+async function askYesNo(rl, prompt, fallback) {
+  const answer = (await rl.question(prompt)).trim().toLowerCase();
+  if (!answer) {
+    return fallback;
+  }
+  if (["y", "yes"].includes(answer)) {
+    return true;
+  }
+  if (["n", "no"].includes(answer)) {
+    return false;
+  }
+  return askYesNo(rl, prompt, fallback);
+}
+async function promptForApiKeys(rl, config2) {
+  const updated = {};
+  const uniqueEnvVars = Array.from(
+    new Set(config2.brains.map((brain) => brain.apiKeyEnvVar))
+  );
+  process.stdout.write("\nAPI key setup (stored in environment variables):\n");
+  for (const envVar of uniqueEnvVars) {
+    const alreadySet = Boolean(process.env[envVar]);
+    const shouldSet = await askYesNo(
+      rl,
+      `${envVar} ${alreadySet ? "(already set)" : "(missing)"} - set now? (y/n) [${alreadySet ? "n" : "y"}]: `,
+      !alreadySet
+    );
+    if (!shouldSet) {
+      continue;
+    }
+    const secret = await askSecret(rl, `Enter value for ${envVar}: `);
+    if (!secret) {
+      continue;
+    }
+    process.env[envVar] = secret;
+    updated[envVar] = secret;
+  }
+  return updated;
+}
+async function askSecret(rl, prompt) {
+  if (!input.isTTY) {
+    return askRequired(rl, prompt);
+  }
+  output.write(prompt);
+  rl.pause();
+  input.setRawMode(true);
+  input.resume();
+  let value = "";
+  return new Promise((resolve2) => {
+    const onData = (chunk) => {
+      const char = chunk.toString();
+      if (char === "\r" || char === "\n") {
+        input.setRawMode(false);
+        input.pause();
+        input.removeListener("data", onData);
+        output.write("\n");
+        rl.resume();
+        resolve2(value);
+        return;
+      }
+      if (char === "") {
+        process.exit(1);
+      }
+      if (char === "\b" || char === "\x7F") {
+        value = value.slice(0, -1);
+        return;
+      }
+      value += char;
+    };
+    input.on("data", onData);
+  });
+}
+async function persistEnvVars(vars) {
+  if (process.platform === "win32") {
+    for (const [key, value] of Object.entries(vars)) {
+      await execFileAsync("setx", [key, value]);
+    }
+    return;
+  }
+  process.stdout.write(
+    "Non-Windows detected. Please export your keys in your shell profile.\n"
+  );
+}
+async function validateGeminiModels(rl, config2, updatedKeys) {
+  const geminiBrains = config2.brains.filter((brain) => brain.provider === "gemini");
+  if (geminiBrains.length === 0) {
+    return;
+  }
+  const geminiEnvVar = geminiBrains[0].apiKeyEnvVar;
+  const apiKey = updatedKeys[geminiEnvVar] ?? process.env[geminiEnvVar];
+  if (!apiKey) {
+    return;
+  }
+  const shouldCheck = await askYesNo(
+    rl,
+    "Check Gemini model availability now? (y/n) [y]: ",
+    true
+  );
+  if (!shouldCheck) {
+    return;
+  }
+  try {
+    const models = await listGeminiModels(apiKey);
+    const supported = models.filter(
+      (model) => model.supportedGenerationMethods.some(
+        (method) => ["generateContent", "streamGenerateContent"].includes(method)
+      )
+    );
+    for (const brain of geminiBrains) {
+      const exists = supported.some((model) => model.name.endsWith(`/${brain.model}`));
+      if (exists) {
+        continue;
+      }
+      process.stdout.write(
+        `Gemini model not found for ${brain.id}: ${brain.model}
+`
+      );
+      const suggestion = supported.find(
+        (model) => model.name.endsWith("/gemini-2.5-pro")
+      );
+      const recommended = suggestion?.name.split("/").pop() ?? "gemini-2.5-pro";
+      const nextModel = await askRequired(
+        rl,
+        `Enter a supported Gemini model [${recommended}]: `,
+        recommended
+      );
+      brain.model = nextModel;
+    }
+  } catch (error) {
+    process.stderr.write(
+      `Failed to validate Gemini models: ${error.message}
+`
+    );
+  }
+}
+async function listGeminiModels(apiKey) {
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+  );
+  if (!res.ok) {
+    throw new Error(`Gemini ListModels failed: ${res.status}`);
+  }
+  const data = await res.json();
+  return data.models ?? [];
+}
+
+// src/cli/commands/brains.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+function runBrainsList() {
+  const config2 = loadConfig();
+  const lines = config2.brains.map(
+    (brain) => `${brain.id}	${brain.provider}	${brain.model}	${brain.apiKeyEnvVar}`
+  );
+  if (lines.length === 0) {
+    process.stdout.write("No brains configured.\n");
+    return;
+  }
+  process.stdout.write("ID	PROVIDER	MODEL	API_KEY_ENV\n");
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+async function runBrainsTest(id) {
+  try {
+    const config2 = loadConfig();
+    const brain = config2.brains.find((entry) => entry.id === id);
+    if (!brain) {
+      throw new Error(`Brain not found: ${id}`);
+    }
+    const adapter = createAdapter(brain);
+    const result = await adapter.ping();
+    if (!result.ok) {
+      throw new Error(result.error ?? "Ping failed");
+    }
+    process.stdout.write(
+      `Brain ${id} ok${result.latencyMs ? ` (${result.latencyMs}ms)` : ""}
+`
+    );
+  } catch (error) {
+    process.stderr.write(`Brain test failed: ${error.message}
+`);
+    process.exit(1);
+  }
+}
+async function runBrainsAdd() {
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    const config2 = loadConfig();
+    const id = await askRequired2(rl, "Brain id (unique): ");
+    if (config2.brains.some((brain) => brain.id === id)) {
+      throw new Error(`Brain id already exists: ${id}`);
+    }
+    const provider = await askRequired2(
+      rl,
+      "Provider (anthropic|openai|gemini|mock): "
+    );
+    if (!["anthropic", "openai", "gemini", "mock"].includes(provider)) {
+      throw new Error(`Unsupported provider: ${provider}`);
+    }
+    const model = await askRequired2(rl, "Model name: ");
+    const suggestedEnv = defaultEnvVar(provider);
+    const apiKeyEnvVar = await askRequired2(
+      rl,
+      `API key env var (${suggestedEnv}): `,
+      suggestedEnv
+    );
+    const next = {
+      id,
+      provider,
+      model,
+      apiKeyEnvVar
+    };
+    saveConfig({
+      ...config2,
+      brains: [...config2.brains, next]
+    });
+    process.stdout.write(`Added brain ${id}.
+`);
+  } catch (error) {
+    process.stderr.write(`Failed to add brain: ${error.message}
+`);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+async function askRequired2(rl, prompt, fallback) {
+  const answer = (await rl.question(prompt)).trim();
+  if (answer) {
+    return answer;
+  }
+  if (fallback) {
+    return fallback;
+  }
+  return askRequired2(rl, prompt, fallback);
+}
+function defaultEnvVar(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "gemini":
+      return "GOOGLE_API_KEY";
+    case "mock":
+      return "MOCK_API_KEY";
+    default:
+      return "API_KEY";
+  }
+}
+
+// src/cli/commands/history.ts
+import { writeFile } from "fs/promises";
+function runHistoryList() {
+  const entries = listHistory();
+  if (entries.length === 0) {
+    process.stdout.write("No history yet.\n");
+    return;
+  }
+  process.stdout.write("ID	CREATED	QUESTION\n");
+  for (const entry of entries) {
+    const question = entry.question.length > 80 ? `${entry.question.slice(0, 77)}...` : entry.question;
+    process.stdout.write(`${entry.id}	${entry.createdAt}	${question}
+`);
+  }
+}
+function runHistoryShow(id) {
+  const entry = getHistory(id);
+  if (!entry) {
+    process.stderr.write(`History entry not found: ${id}
+`);
+    process.exit(1);
+  }
+  process.stdout.write(JSON.stringify(entry, null, 2));
+  process.stdout.write("\n");
+}
+async function runHistoryExport(id, file) {
+  const entry = getHistory(id);
+  if (!entry) {
+    process.stderr.write(`History entry not found: ${id}
+`);
+    process.exit(1);
+  }
+  const payload = JSON.stringify(entry, null, 2);
+  await writeFile(file, payload);
+  process.stdout.write(`Exported history ${id} to ${file}.
+`);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("mirror").description("Adversarial Mirror CLI").version("0.1.0").option("--intensity <level>", "mild|moderate|aggressive").option("--original <brainId>", "override original brain").option("--challenger <brainId>", "override challenger brain").option("--no-mirror", "disable mirroring").option("--no-classify", "disable intent classification").option("--no-judge", "disable judge synthesis pass").option("--judge-brain <brainId>", "override judge brain id").option("--persona <name>", "persona lens: vc-skeptic|security-auditor|end-user|regulator|contrarian").option("--debug", "enable debug logging");
+program.command("chat").description("Interactive session").option("--file <path>", "load file as context before the session starts").action(runChat);
+program.command("mirror <question>").description("One-shot query").option("--file <path>", "load file as context (or pipe via stdin)").action(runMirror);
+var config = program.command("config").description("Config commands");
+config.action(runConfigShow);
+config.command("show").description("Show current config").action(runConfigShow);
+config.command("init").description("Interactive setup wizard").action(runConfigInit);
+config.command("set <key> <value>").description("Set config value by key path").action(runConfigSet);
+var brains = program.command("brains").description("Brain management commands");
+brains.action(runBrainsList);
+brains.command("list").description("List configured brains").action(runBrainsList);
+brains.command("test <id>").description("Test a brain").action(runBrainsTest);
+brains.command("add").description("Add a new brain").action(runBrainsAdd);
+var history = program.command("history").description("History commands");
+history.action(runHistoryList);
+history.command("list").description("List history").action(runHistoryList);
+history.command("show <id>").description("Show history entry").action(runHistoryShow);
+history.command("export <id> <file>").description("Export history entry to a file").action(runHistoryExport);
+var rawArgs = process.argv.slice(2);
+var knownSubcommands = /* @__PURE__ */ new Set(["chat", "mirror", "config", "brains", "history"]);
+var hasVersionOrHelp = rawArgs.some((a) => ["-V", "--version", "-h", "--help"].includes(a));
+var hasSubcommand = rawArgs.some((a) => knownSubcommands.has(a));
+if (!hasVersionOrHelp && !hasSubcommand) {
+  process.argv.push("chat");
+}
+program.parse();
+//# sourceMappingURL=cli.js.map