@statechange/council 0.1.0

package/dist-electron/main.js

@@ -0,0 +1,1635 @@
+import { shell, dialog, protocol, app, net, BrowserWindow, ipcMain } from "electron";
+import { join, basename, resolve, dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, writeFileSync, appendFileSync } from "node:fs";
+import { readFile, readdir, stat, mkdir, rm, writeFile, appendFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { homedir } from "node:os";
+import matter from "gray-matter";
+import { z } from "zod";
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { Ollama } from "ollama";
+import { createRequire } from "node:module";
+import "dotenv/config";
+const CounsellorFrontmatterSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  interests: z.array(z.string()).default([]),
+  backend: z.enum(["anthropic", "openai", "google", "ollama"]),
+  model: z.string().optional(),
+  skills: z.array(z.string()).default([]),
+  temperature: z.number().min(0).max(2).optional(),
+  avatar: z.string().optional()
+});
+const searchPaths = (counsellorDir, skillName) => [
+  join(counsellorDir, "skills", skillName, "SKILL.md"),
+  join(process.cwd(), ".claude", "skills", skillName, "SKILL.md"),
+  join(homedir(), ".agents", "skills", skillName, "SKILL.md"),
+  join(homedir(), ".claude", "skills", skillName, "SKILL.md")
+];
+async function resolveSkill(skillName, counsellorDir) {
+  for (const candidate of searchPaths(counsellorDir, skillName)) {
+    if (existsSync(candidate)) {
+      const raw = await readFile(candidate, "utf-8");
+      const { content } = matter(raw);
+      return content.trim();
+    }
+  }
+  return null;
+}
+async function resolveSkills(skillNames, counsellorDir) {
+  const sections = [];
+  for (const name of skillNames) {
+    const content = await resolveSkill(name, counsellorDir);
+    if (content) {
+      sections.push(`## Skill: ${name}
+
+${content}`);
+    }
+  }
+  return sections.join("\n\n");
+}
+function resolveAvatar(avatar, dirPath) {
+  if (!avatar) return void 0;
+  if (avatar.startsWith("http://") || avatar.startsWith("https://")) return avatar;
+  const absPath = avatar.startsWith("/") ? avatar : join(dirPath, avatar);
+  return `council-file://${absPath}`;
+}
+async function resolveReferences(content, counsellorDir) {
+  const refPattern = /\{\{(.+?)\}\}/g;
+  let resolved = content;
+  for (const match of content.matchAll(refPattern)) {
+    const refPath = match[1].trim();
+    const fullPath = join(counsellorDir, refPath);
+    if (existsSync(fullPath)) {
+      const refContent = await readFile(fullPath, "utf-8");
+      resolved = resolved.replace(match[0], refContent.trim());
+    } else {
+      resolved = resolved.replace(match[0], `[Reference not found: ${refPath}]`);
+    }
+  }
+  return resolved;
+}
+async function loadSingleCounsellor(dirPath) {
+  const absPath = resolve(dirPath);
+  const aboutPath = join(absPath, "ABOUT.md");
+  if (!existsSync(aboutPath)) {
+    throw new Error(`No ABOUT.md found in ${absPath}`);
+  }
+  const raw = await readFile(aboutPath, "utf-8");
+  const { data, content } = matter(raw);
+  const frontmatter = CounsellorFrontmatterSchema.parse(data);
+  let systemPrompt = await resolveReferences(content.trim(), absPath);
+  if (frontmatter.skills.length > 0) {
+    const skillContent = await resolveSkills(frontmatter.skills, absPath);
+    if (skillContent) {
+      systemPrompt += "\n\n" + skillContent;
+    }
+  }
+  return {
+    id: basename(absPath),
+    frontmatter,
+    systemPrompt,
+    dirPath: absPath,
+    avatarUrl: resolveAvatar(frontmatter.avatar, absPath)
+  };
+}
+async function loadCounsellors(councilDir, registeredPaths) {
+  const counsellors = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  if (registeredPaths?.length) {
+    for (const rPath of registeredPaths) {
+      if (!existsSync(join(rPath, "ABOUT.md"))) continue;
+      try {
+        const c = await loadSingleCounsellor(rPath);
+        if (!seenIds.has(c.id)) {
+          counsellors.push(c);
+          seenIds.add(c.id);
+        }
+      } catch {
+      }
+    }
+  }
+  if (existsSync(councilDir)) {
+    const entries = await readdir(councilDir);
+    for (const entry of entries) {
+      const entryPath = join(councilDir, entry);
+      const info = await stat(entryPath);
+      if (info.isDirectory() && existsSync(join(entryPath, "ABOUT.md"))) {
+        if (!seenIds.has(basename(entryPath))) {
+          counsellors.push(await loadSingleCounsellor(entryPath));
+          seenIds.add(basename(entryPath));
+        }
+      }
+    }
+  }
+  if (counsellors.length === 0) {
+    throw new Error(`No counsellors found in ${councilDir}. Each counsellor needs a directory with an ABOUT.md file.`);
+  }
+  return counsellors;
+}
+const execFileAsync = promisify(execFile);
+const CONFIG_PATH = join(homedir(), ".ai-council", "config.json");
+const CLONES_DIR = join(homedir(), ".ai-council", "counsellors");
+async function loadConfig$1() {
+  try {
+    return JSON.parse(await readFile(CONFIG_PATH, "utf-8"));
+  } catch {
+    return { backends: {} };
+  }
+}
+async function saveConfig(config) {
+  const dir = join(homedir(), ".ai-council");
+  await mkdir(dir, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function getRegisteredPaths(config) {
+  return Object.values(config.counsellors ?? {}).map((e) => e.path);
+}
+async function addLocalCounsellor(dirPath) {
+  const absPath = resolve(dirPath);
+  const aboutPath = join(absPath, "ABOUT.md");
+  if (!existsSync(aboutPath)) {
+    throw new Error(`No ABOUT.md found in ${absPath}`);
+  }
+  const id = basename(absPath);
+  const config = await loadConfig$1();
+  const registry = config.counsellors ?? {};
+  if (registry[id]) {
+    throw new Error(`Counsellor "${id}" is already registered (path: ${registry[id].path})`);
+  }
+  const raw = await readFile(aboutPath, "utf-8");
+  const nameMatch = raw.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+  const displayName = nameMatch?.[1] ?? id;
+  registry[id] = {
+    path: absPath,
+    source: "local",
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  config.counsellors = registry;
+  await saveConfig(config);
+  return { id, name: displayName };
+}
+async function addRemoteCounsellor(url) {
+  await mkdir(CLONES_DIR, { recursive: true });
+  const repoName = basename(url, ".git").replace(/\.git$/, "");
+  const clonePath = join(CLONES_DIR, repoName);
+  if (existsSync(clonePath)) {
+    throw new Error(`Directory already exists: ${clonePath}. Remove it first or use a different URL.`);
+  }
+  await execFileAsync("git", ["clone", "--depth", "1", url, clonePath]);
+  const results = [];
+  const config = await loadConfig$1();
+  const registry = config.counsellors ?? {};
+  if (existsSync(join(clonePath, "ABOUT.md"))) {
+    const id = repoName;
+    if (registry[id]) {
+      throw new Error(`Counsellor "${id}" is already registered`);
+    }
+    const raw = await readFile(join(clonePath, "ABOUT.md"), "utf-8");
+    const nameMatch = raw.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+    const displayName = nameMatch?.[1] ?? id;
+    registry[id] = {
+      path: clonePath,
+      source: "git",
+      url,
+      addedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    results.push({ id, name: displayName });
+  } else {
+    const entries = await readdir(clonePath);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const entryPath = join(clonePath, entry);
+      const info = await stat(entryPath);
+      if (info.isDirectory() && existsSync(join(entryPath, "ABOUT.md"))) {
+        const id = entry;
+        if (registry[id]) continue;
+        const raw = await readFile(join(entryPath, "ABOUT.md"), "utf-8");
+        const nameMatch = raw.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+        const displayName = nameMatch?.[1] ?? id;
+        registry[id] = {
+          path: entryPath,
+          source: "git",
+          url,
+          addedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        results.push({ id, name: displayName });
+      }
+    }
+    if (results.length === 0) {
+      await rm(clonePath, { recursive: true, force: true });
+      throw new Error(`No counsellors found in cloned repository (no ABOUT.md files)`);
+    }
+  }
+  config.counsellors = registry;
+  await saveConfig(config);
+  return results;
+}
+async function removeCounsellor(id, deleteFiles = false) {
+  const config = await loadConfig$1();
+  const registry = config.counsellors ?? {};
+  const entry = registry[id];
+  if (!entry) {
+    throw new Error(`Counsellor "${id}" is not registered`);
+  }
+  if (deleteFiles && entry.source === "git" && existsSync(entry.path)) {
+    await rm(entry.path, { recursive: true, force: true });
+  }
+  delete registry[id];
+  config.counsellors = registry;
+  await saveConfig(config);
+}
+function createAnthropicBackend(config) {
+  const client = new Anthropic({
+    apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY,
+    ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+  });
+  return {
+    name: "anthropic",
+    defaultModel: "claude-sonnet-4-5-20250929",
+    async chat(request) {
+      const response = await client.messages.create({
+        model: request.model,
+        max_tokens: 4096,
+        system: request.systemPrompt,
+        messages: request.messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+      });
+      const textBlock = response.content.find((b) => b.type === "text");
+      return {
+        content: textBlock?.text ?? "",
+        tokenUsage: {
+          input: response.usage.input_tokens,
+          output: response.usage.output_tokens
+        }
+      };
+    },
+    async *chatStream(request) {
+      const stream = client.messages.stream({
+        model: request.model,
+        max_tokens: 4096,
+        system: request.systemPrompt,
+        messages: request.messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          yield { delta: event.delta.text };
+        }
+      }
+      const finalMessage = await stream.finalMessage();
+      yield {
+        delta: "",
+        tokenUsage: {
+          input: finalMessage.usage.input_tokens,
+          output: finalMessage.usage.output_tokens
+        }
+      };
+    }
+  };
+}
+function createOpenAIBackend(config) {
+  const client = new OpenAI({
+    apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
+    ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+  });
+  return {
+    name: "openai",
+    defaultModel: "gpt-4o",
+    async chat(request) {
+      const response = await client.chat.completions.create({
+        model: request.model,
+        messages: [
+          { role: "system", content: request.systemPrompt },
+          ...request.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        ],
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+      });
+      const choice = response.choices[0];
+      return {
+        content: choice?.message?.content ?? "",
+        tokenUsage: response.usage ? { input: response.usage.prompt_tokens, output: response.usage.completion_tokens } : void 0
+      };
+    },
+    async *chatStream(request) {
+      const stream = await client.chat.completions.create({
+        model: request.model,
+        messages: [
+          { role: "system", content: request.systemPrompt },
+          ...request.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        ],
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+        stream: true,
+        stream_options: { include_usage: true }
+      });
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta) {
+          yield { delta };
+        }
+        if (chunk.usage) {
+          yield {
+            delta: "",
+            tokenUsage: {
+              input: chunk.usage.prompt_tokens,
+              output: chunk.usage.completion_tokens
+            }
+          };
+        }
+      }
+    }
+  };
+}
+function createGoogleBackend(config) {
+  const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? "";
+  const genAI = new GoogleGenerativeAI(apiKey);
+  return {
+    name: "google",
+    defaultModel: "gemini-2.0-flash",
+    async chat(request) {
+      const model = genAI.getGenerativeModel({
+        model: request.model,
+        systemInstruction: request.systemPrompt,
+        generationConfig: {
+          ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+        }
+      });
+      const history = request.messages.slice(0, -1).map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      }));
+      const chat = model.startChat({ history });
+      const lastMessage = request.messages[request.messages.length - 1];
+      const result = await chat.sendMessage(lastMessage?.content ?? "");
+      const response = result.response;
+      return {
+        content: response.text(),
+        tokenUsage: response.usageMetadata ? {
+          input: response.usageMetadata.promptTokenCount ?? 0,
+          output: response.usageMetadata.candidatesTokenCount ?? 0
+        } : void 0
+      };
+    },
+    async *chatStream(request) {
+      const genModel = genAI.getGenerativeModel({
+        model: request.model,
+        systemInstruction: request.systemPrompt,
+        generationConfig: {
+          ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+        }
+      });
+      const history = request.messages.slice(0, -1).map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      }));
+      const chat = genModel.startChat({ history });
+      const lastMessage = request.messages[request.messages.length - 1];
+      const result = await chat.sendMessageStream(lastMessage?.content ?? "");
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          yield { delta: text };
+        }
+      }
+      const response = await result.response;
+      yield {
+        delta: "",
+        tokenUsage: response.usageMetadata ? {
+          input: response.usageMetadata.promptTokenCount ?? 0,
+          output: response.usageMetadata.candidatesTokenCount ?? 0
+        } : void 0
+      };
+    }
+  };
+}
+function createOllamaBackend(config) {
+  const client = new Ollama({
+    host: config.baseUrl ?? "http://localhost:11434"
+  });
+  return {
+    name: "ollama",
+    defaultModel: "llama3.2",
+    async chat(request) {
+      const response = await client.chat({
+        model: request.model,
+        messages: [
+          { role: "system", content: request.systemPrompt },
+          ...request.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        ],
+        options: {
+          ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+        }
+      });
+      return {
+        content: response.message.content,
+        tokenUsage: response.prompt_eval_count !== void 0 ? {
+          input: response.prompt_eval_count ?? 0,
+          output: response.eval_count ?? 0
+        } : void 0
+      };
+    },
+    async *chatStream(request) {
+      const response = await client.chat({
+        model: request.model,
+        messages: [
+          { role: "system", content: request.systemPrompt },
+          ...request.messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        ],
+        options: {
+          ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+        },
+        stream: true
+      });
+      let promptEvalCount;
+      let evalCount;
+      for await (const chunk of response) {
+        if (chunk.message.content) {
+          yield { delta: chunk.message.content };
+        }
+        if (chunk.done) {
+          promptEvalCount = chunk.prompt_eval_count;
+          evalCount = chunk.eval_count;
+        }
+      }
+      yield {
+        delta: "",
+        tokenUsage: promptEvalCount !== void 0 ? { input: promptEvalCount ?? 0, output: evalCount ?? 0 } : void 0
+      };
+    }
+  };
+}
+const factories = {
+  anthropic: createAnthropicBackend,
+  openai: createOpenAIBackend,
+  google: createGoogleBackend,
+  ollama: createOllamaBackend
+};
+let configCache = null;
+async function loadConfig() {
+  if (configCache) return configCache;
+  const configPath = join(homedir(), ".ai-council", "config.json");
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    configCache = JSON.parse(raw);
+  } catch {
+    configCache = { backends: {} };
+  }
+  return configCache;
+}
+const backendCache = /* @__PURE__ */ new Map();
+function clearCaches() {
+  configCache = null;
+  backendCache.clear();
+}
+async function getBackend(name) {
+  const cached = backendCache.get(name);
+  if (cached) return cached;
+  const factory = factories[name];
+  if (!factory) {
+    throw new Error(`Unknown backend: "${name}". Available: ${Object.keys(factories).join(", ")}`);
+  }
+  const config = await loadConfig();
+  const backendConfig = config.backends[name] ?? {};
+  const backend = factory(backendConfig);
+  backendCache.set(name, backend);
+  return backend;
+}
+function getExcalidrawCheatsheet() {
+  return `
+## Excalidraw Element Reference
+
+Output a JSON array of Excalidraw elements. Each element needs these fields:
+
+### Common Fields (all elements)
+- \`type\`: "rectangle" | "ellipse" | "diamond" | "text" | "arrow" | "line"
+- \`id\`: unique string (e.g. "rect1", "text1", "arrow1")
+- \`x\`, \`y\`: number (top-left origin, x increases right, y increases down)
+- \`width\`, \`height\`: number
+- \`strokeColor\`: hex string (e.g. "#1e1e1e")
+- \`backgroundColor\`: hex string or "transparent"
+- \`fillStyle\`: "solid" | "hachure" | "cross-hatch"
+- \`strokeWidth\`: 1 | 2 | 4
+- \`roughness\`: 0 (sharp) | 1 (sketchy)
+- \`opacity\`: 100
+- \`angle\`: 0
+- \`seed\`: any integer (e.g. 1)
+- \`version\`: 1
+- \`isDeleted\`: false
+- \`groupIds\`: []
+- \`boundElements\`: null or array of { id: string, type: "text" | "arrow" }
+- \`link\`: null
+- \`locked\`: false
+
+### Text Elements
+Additional fields: \`text\`, \`fontSize\` (16-24), \`fontFamily\` (1=hand, 2=normal, 3=mono), \`textAlign\` ("left"|"center"|"right"), \`verticalAlign\` ("top"|"middle"), \`baseline\`: 0, \`containerId\`: null or parent shape id
+
+### Arrow/Line Elements
+Additional fields: \`points\` (array of [x,y] relative to element x,y — first point always [0,0]), \`startBinding\` and \`endBinding\`: null or { elementId: string, focus: 0, gap: 5 }, \`lastCommittedPoint\`: null, \`startArrowhead\`: null, \`endArrowhead\`: "arrow" | null
+
+### Color Palette
+- Blue: "#1971c2", Light blue bg: "#a5d8ff"
+- Green: "#2f9e44", Light green bg: "#b2f2bb"
+- Red: "#e03131", Light red bg: "#ffc9c9"
+- Orange: "#e8590c", Light orange bg: "#ffd8a8"
+- Purple: "#7048e8", Light purple bg: "#d0bfff"
+- Yellow: "#f08c00", Light yellow bg: "#ffec99"
+- Gray: "#868e96", Light gray bg: "#dee2e6"
+- Dark: "#1e1e1e"
+
+### Layout Tips
+- Space shapes ~200px apart horizontally, ~150px vertically
+- Typical shape size: 160×80 for rectangles, 120×60 for ellipses
+- Center text inside shapes using containerId
+- Use arrows to show relationships (agreement, disagreement, influence)
+
+### Compact Example
+\`\`\`json
+[
+  {"type":"rectangle","id":"r1","x":50,"y":50,"width":160,"height":80,"strokeColor":"#1971c2","backgroundColor":"#a5d8ff","fillStyle":"solid","strokeWidth":2,"roughness":1,"opacity":100,"angle":0,"seed":1,"version":1,"isDeleted":false,"groupIds":[],"boundElements":[{"id":"t1","type":"text"},{"id":"a1","type":"arrow"}],"link":null,"locked":false},
+  {"type":"text","id":"t1","x":60,"y":70,"width":140,"height":40,"text":"Counsellor A","fontSize":16,"fontFamily":2,"textAlign":"center","verticalAlign":"middle","baseline":0,"containerId":"r1","strokeColor":"#1e1e1e","backgroundColor":"transparent","fillStyle":"solid","strokeWidth":1,"roughness":0,"opacity":100,"angle":0,"seed":2,"version":1,"isDeleted":false,"groupIds":[],"boundElements":null,"link":null,"locked":false},
+  {"type":"rectangle","id":"r2","x":350,"y":50,"width":160,"height":80,"strokeColor":"#2f9e44","backgroundColor":"#b2f2bb","fillStyle":"solid","strokeWidth":2,"roughness":1,"opacity":100,"angle":0,"seed":3,"version":1,"isDeleted":false,"groupIds":[],"boundElements":[{"id":"t2","type":"text"},{"id":"a1","type":"arrow"}],"link":null,"locked":false},
+  {"type":"text","id":"t2","x":360,"y":70,"width":140,"height":40,"text":"Counsellor B","fontSize":16,"fontFamily":2,"textAlign":"center","verticalAlign":"middle","baseline":0,"containerId":"r2","strokeColor":"#1e1e1e","backgroundColor":"transparent","fillStyle":"solid","strokeWidth":1,"roughness":0,"opacity":100,"angle":0,"seed":4,"version":1,"isDeleted":false,"groupIds":[],"boundElements":null,"link":null,"locked":false},
+  {"type":"arrow","id":"a1","x":210,"y":90,"width":140,"height":0,"points":[[0,0],[140,0]],"startBinding":{"elementId":"r1","focus":0,"gap":5},"endBinding":{"elementId":"r2","focus":0,"gap":5},"startArrowhead":null,"endArrowhead":"arrow","strokeColor":"#1e1e1e","backgroundColor":"transparent","fillStyle":"solid","strokeWidth":2,"roughness":1,"opacity":100,"angle":0,"seed":5,"version":1,"isDeleted":false,"groupIds":[],"boundElements":null,"link":null,"locked":false,"lastCommittedPoint":null}
+]
+\`\`\`
+`.trim();
+}
+const EXCALIDRAW_DELIMITER = "---EXCALIDRAW---";
+const DEFAULT_SYSTEM_PROMPT = `You are the Secretary of a council discussion. Your job is to synthesize a clear, structured summary of the conversation that just took place.
+
+Structure your summary with these sections:
+
+## Individual Positions
+Briefly summarize each counsellor's key arguments and stance.
+
+## Points of Convergence
+Where did the counsellors agree? What common ground emerged?
+
+## Points of Divergence
+Where did they disagree? What are the key tensions?
+
+## Synthesis
+What are the most important takeaways? What would you recommend based on the full discussion?
+
+Be concise but thorough. Use markdown formatting.`;
+function buildTranscript(result) {
+  const lines = [];
+  lines.push(`Topic: ${result.topic}`);
+  lines.push(`Counsellors: ${result.counsellors.map((c) => c.name).join(", ")}`);
+  lines.push(`Rounds: ${result.rounds}`);
+  lines.push("");
+  let currentRound = 0;
+  for (const turn of result.turns) {
+    if (turn.round !== currentRound) {
+      currentRound = turn.round;
+      lines.push(`--- Round ${currentRound} ---`);
+      lines.push("");
+    }
+    lines.push(`[${turn.counsellorName}]:`);
+    lines.push(turn.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function runSecretary({
+  result,
+  config,
+  onChunk,
+  signal
+}) {
+  const secretaryConfig = config.secretary;
+  if (!secretaryConfig?.backend) {
+    throw new Error("No secretary backend configured");
+  }
+  const backend = await getBackend(secretaryConfig.backend);
+  const model = secretaryConfig.model ?? backend.defaultModel;
+  const basePrompt = secretaryConfig.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+  const cheatsheet = getExcalidrawCheatsheet();
+  const systemPrompt = `${basePrompt}
+
+${cheatsheet}
+
+After your text summary, output \`${EXCALIDRAW_DELIMITER}\` on its own line, then a JSON array of Excalidraw elements showing a visual map of where each counsellor stands on the topic. Use shapes for each counsellor with their name, arrows to show relationships (agreement/disagreement), and position them to visually represent the discussion dynamics.`;
+  const transcript = buildTranscript(result);
+  const chatRequest = {
+    model,
+    systemPrompt,
+    messages: [{ role: "user", content: `Please summarize this council discussion and create a position diagram:
+
+${transcript}` }],
+    temperature: 0.5
+  };
+  let fullResponse = "";
+  if (backend.chatStream) {
+    for await (const chunk of backend.chatStream(chatRequest)) {
+      if (signal?.aborted) break;
+      fullResponse += chunk.delta;
+      if (chunk.delta && onChunk) {
+        onChunk(chunk.delta);
+      }
+    }
+  } else {
+    const response = await backend.chat(chatRequest);
+    fullResponse = response.content;
+    if (onChunk) onChunk(fullResponse);
+  }
+  const delimiterIndex = fullResponse.indexOf(EXCALIDRAW_DELIMITER);
+  if (delimiterIndex === -1) {
+    return { text: fullResponse.trim() };
+  }
+  const text = fullResponse.slice(0, delimiterIndex).trim();
+  const diagramRaw = fullResponse.slice(delimiterIndex + EXCALIDRAW_DELIMITER.length).trim();
+  let diagram;
+  try {
+    const jsonMatch = diagramRaw.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      diagram = JSON.parse(jsonMatch[0]);
+    }
+  } catch {
+  }
+  return { text, diagram };
+}
+const INTERIM_SYSTEM_PROMPT = `You are the Secretary of a council debate. Briefly summarize this round of discussion. Note emerging agreements, disagreements, and shifts in position. 2-3 paragraphs max. Use markdown formatting.`;
+async function runInterimSummary({
+  result,
+  roundNumber,
+  config,
+  onChunk,
+  signal
+}) {
+  const secretaryConfig = config.secretary;
+  if (!secretaryConfig?.backend) {
+    throw new Error("No secretary backend configured");
+  }
+  const backend = await getBackend(secretaryConfig.backend);
+  const model = secretaryConfig.model ?? backend.defaultModel;
+  const roundTurns = result.turns.filter((t) => t.round === roundNumber);
+  const lines = [];
+  lines.push(`Topic: ${result.topic}`);
+  lines.push(`Round ${roundNumber}${roundNumber === 1 ? " (Constructive)" : " (Rebuttal)"}`);
+  lines.push("");
+  for (const turn of roundTurns) {
+    lines.push(`[${turn.counsellorName}]:`);
+    lines.push(turn.content);
+    lines.push("");
+  }
+  const chatRequest = {
+    model,
+    systemPrompt: INTERIM_SYSTEM_PROMPT,
+    messages: [{ role: "user", content: `Please summarize this round:
+
+${lines.join("\n")}` }],
+    temperature: 0.5
+  };
+  let fullResponse = "";
+  if (backend.chatStream) {
+    for await (const chunk of backend.chatStream(chatRequest)) {
+      if (signal?.aborted) break;
+      fullResponse += chunk.delta;
+      if (chunk.delta && onChunk) {
+        onChunk(chunk.delta);
+      }
+    }
+  } else {
+    const response = await backend.chat(chatRequest);
+    fullResponse = response.content;
+    if (onChunk) onChunk(fullResponse);
+  }
+  return fullResponse.trim();
+}
+async function generateTitle({
+  topic,
+  firstRoundTurns,
+  config
+}) {
+  const secretaryConfig = config.secretary;
+  if (!secretaryConfig?.backend) {
+    throw new Error("No secretary backend configured");
+  }
+  const backend = await getBackend(secretaryConfig.backend);
+  const model = secretaryConfig.model ?? backend.defaultModel;
+  const turnsSummary = firstRoundTurns.map((t) => `[${t.counsellorName}]: ${t.content.slice(0, 300)}`).join("\n\n");
+  const response = await backend.chat({
+    model,
+    systemPrompt: "Generate a concise title (max 8 words) for this council discussion. Return only the title, no quotes or punctuation at the end.",
+    messages: [
+      {
+        role: "user",
+        content: `Topic: ${topic}
+
+First round:
+${turnsSummary}`
+      }
+    ],
+    temperature: 0.3
+  });
+  return response.content.trim().replace(/^["']+|["']+$/g, "").replace(/[.!?]+$/, "").trim();
+}
+const LOG_DIR = join(homedir(), ".ai-council");
+const LOG_FILE = join(LOG_DIR, "council.log");
+let ensured = false;
+async function ensureDir() {
+  if (ensured) return;
+  await mkdir(LOG_DIR, { recursive: true });
+  ensured = true;
+}
+function formatEntry(level, context, message, extra) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  let line = `[${ts}] ${level} [${context}] ${message}`;
+  if (extra !== void 0) {
+    const detail = extra instanceof Error ? `${extra.message}
+${extra.stack ?? ""}` : typeof extra === "string" ? extra : JSON.stringify(extra, null, 2);
+    line += `
+  ${detail.replace(/\n/g, "\n  ")}`;
+  }
+  return line + "\n";
+}
+async function write(level, context, message, extra) {
+  try {
+    await ensureDir();
+    await appendFile(LOG_FILE, formatEntry(level, context, message, extra));
+  } catch {
+  }
+}
+const log$1 = {
+  info: (context, message, extra) => write("INFO", context, message, extra),
+  warn: (context, message, extra) => write("WARN", context, message, extra),
+  error: (context, message, extra) => write("ERROR", context, message, extra)
+};
+function buildMessages(topic, turns, currentCounsellorId) {
+  const messages = [{ role: "user", content: topic }];
+  for (const turn of turns) {
+    if (turn.counsellorId === currentCounsellorId) {
+      messages.push({ role: "assistant", content: turn.content });
+    } else {
+      messages.push({
+        role: "user",
+        content: `[${turn.counsellorName}, Round ${turn.round}]: ${turn.content}`
+      });
+    }
+  }
+  return messages;
+}
+function buildDebateMessages(topic, turns, currentCounsellorId, currentRound) {
+  const messages = [{ role: "user", content: topic }];
+  if (currentRound === 1) {
+    return messages;
+  }
+  const constructiveTurns = turns.filter((t) => t.round === 1);
+  for (const turn of constructiveTurns) {
+    if (turn.counsellorId === currentCounsellorId) {
+      messages.push({ role: "assistant", content: turn.content });
+    } else {
+      messages.push({
+        role: "user",
+        content: `[${turn.counsellorName}, Constructive]: ${turn.content}`
+      });
+    }
+  }
+  const prevRound = currentRound - 1;
+  if (prevRound > 1) {
+    const prevTurns = turns.filter((t) => t.round === prevRound);
+    for (const turn of prevTurns) {
+      if (turn.counsellorId === currentCounsellorId) {
+        messages.push({ role: "assistant", content: turn.content });
+      } else {
+        messages.push({
+          role: "user",
+          content: `[${turn.counsellorName}, Round ${prevRound}]: ${turn.content}`
+        });
+      }
+    }
+  }
+  for (const turn of turns) {
+    if (turn.counsellorId === currentCounsellorId && turn.round !== 1 && turn.round !== prevRound && turn.round < currentRound) {
+      messages.push({ role: "assistant", content: turn.content });
+    }
+  }
+  return messages;
+}
+function shuffleWithSeed(array, seed) {
+  const result = [...array];
+  let s = seed | 0;
+  const rand = () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function buildResult(opts, turns, startedAt, totalInput, totalOutput, roundSummaries) {
+  return {
+    topic: opts.topic,
+    topicSource: opts.topicSource,
+    counsellors: opts.counsellors.map((c) => ({
+      id: c.id,
+      name: c.frontmatter.name,
+      description: c.frontmatter.description,
+      backend: c.frontmatter.backend,
+      model: c.frontmatter.model ?? "default",
+      avatarUrl: c.avatarUrl
+    })),
+    rounds: opts.rounds,
+    turns,
+    startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalTokenUsage: { input: totalInput, output: totalOutput },
+    ...roundSummaries && Object.keys(roundSummaries).length > 0 ? { roundSummaries } : {},
+    ...opts.mode === "debate" ? { mode: "debate" } : {}
+  };
+}
+async function runConversation(topicOrOpts, topicSource, counsellors, rounds, onEvent) {
+  let opts;
+  if (typeof topicOrOpts === "string") {
+    opts = {
+      topic: topicOrOpts,
+      topicSource,
+      counsellors,
+      rounds,
+      onEvent
+    };
+  } else {
+    opts = topicOrOpts;
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const turns = [];
+  let totalInput = 0;
+  let totalOutput = 0;
+  const isDebate = opts.mode === "debate";
+  const roundSummaries = {};
+  log$1.info("conversation", `Starting ${isDebate ? "debate" : "freeform"} — ${opts.counsellors.length} counsellors, ${opts.rounds} rounds`, {
+    counsellors: opts.counsellors.map((c) => `${c.frontmatter.name} (${c.frontmatter.backend}/${c.frontmatter.model ?? "default"})`),
+    topic: opts.topic.slice(0, 200)
+  });
+  for (let round = 1; round <= opts.rounds; round++) {
+    const roundCounsellors = isDebate && round > 1 ? shuffleWithSeed(opts.counsellors, round) : opts.counsellors;
+    for (const counsellor of roundCounsellors) {
+      if (opts.signal?.aborted) {
+        return buildResult(opts, turns, startedAt, totalInput, totalOutput, roundSummaries);
+      }
+      if (opts.beforeTurn) {
+        const injected = await opts.beforeTurn();
+        if (injected) {
+          turns.push(injected);
+          opts.onEvent({ type: "turn_complete", turn: injected });
+        }
+      }
+      opts.onEvent({ type: "turn_start", round, counsellorName: counsellor.frontmatter.name });
+      try {
+        const backend = await getBackend(counsellor.frontmatter.backend);
+        const model = counsellor.frontmatter.model ?? backend.defaultModel;
+        const messages = isDebate ? buildDebateMessages(opts.topic, turns, counsellor.id, round) : buildMessages(opts.topic, turns, counsellor.id);
+        const chatRequest = {
+          model,
+          systemPrompt: counsellor.systemPrompt,
+          messages,
+          temperature: counsellor.frontmatter.temperature
+        };
+        let content;
+        let tokenUsage;
+        if (backend.chatStream) {
+          content = "";
+          for await (const chunk of backend.chatStream(chatRequest)) {
+            if (opts.signal?.aborted) break;
+            content += chunk.delta;
+            if (chunk.delta) {
+              opts.onEvent({ type: "turn_chunk", counsellorName: counsellor.frontmatter.name, delta: chunk.delta });
+            }
+            if (chunk.tokenUsage) {
+              tokenUsage = chunk.tokenUsage;
+            }
+          }
+        } else {
+          const response = await backend.chat(chatRequest);
+          content = response.content;
+          tokenUsage = response.tokenUsage;
+        }
+        const turn = {
+          round,
+          counsellorId: counsellor.id,
+          counsellorName: counsellor.frontmatter.name,
+          content,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          model,
+          backend: counsellor.frontmatter.backend,
+          tokenUsage,
+          avatarUrl: counsellor.avatarUrl
+        };
+        if (tokenUsage) {
+          totalInput += tokenUsage.input;
+          totalOutput += tokenUsage.output;
+        }
+        turns.push(turn);
+        opts.onEvent({ type: "turn_complete", turn });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log$1.error("conversation", `Turn failed for ${counsellor.frontmatter.name} (round ${round}, model ${counsellor.frontmatter.model ?? "default"}, backend ${counsellor.frontmatter.backend})`, err);
+        opts.onEvent({ type: "error", counsellorName: counsellor.frontmatter.name, error: message });
+      }
+    }
+    opts.onEvent({ type: "round_complete", round });
+    if (isDebate && opts.config?.secretary?.backend && !opts.signal?.aborted) {
+      try {
+        const interimResult = buildResult(opts, turns, startedAt, totalInput, totalOutput, roundSummaries);
+        opts.onEvent({ type: "round_summary_start", round });
+        const summary = await runInterimSummary({
+          result: interimResult,
+          roundNumber: round,
+          config: opts.config,
+          onChunk: (delta) => {
+            opts.onEvent({ type: "round_summary_chunk", round, delta });
+          },
+          signal: opts.signal
+        });
+        roundSummaries[round] = summary;
+        opts.onEvent({ type: "round_summary_complete", round, summary });
+      } catch (err) {
+        log$1.error("conversation", `Interim summary failed for round ${round}`, err);
+      }
+    }
+  }
+  return buildResult(opts, turns, startedAt, totalInput, totalOutput, roundSummaries);
+}
+const HISTORY_DIR = join(homedir(), ".ai-council", "history");
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+async function saveToHistory(result) {
+  await mkdir(HISTORY_DIR, { recursive: true });
+  const timestamp = new Date(result.startedAt).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const slug = slugify(result.topic);
+  const id = `${timestamp}-${slug}`;
+  const filePath = join(HISTORY_DIR, `${id}.json`);
+  await writeFile(filePath, JSON.stringify(result, null, 2), "utf-8");
+  return id;
+}
+async function listHistory() {
+  await mkdir(HISTORY_DIR, { recursive: true });
+  const files = await readdir(HISTORY_DIR);
+  const entries = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const raw = await readFile(join(HISTORY_DIR, file), "utf-8");
+      const result = JSON.parse(raw);
+      entries.push({
+        id: basename(file, ".json"),
+        topic: result.topic,
+        title: result.title,
+        counsellors: result.counsellors.map((c) => c.name),
+        rounds: result.rounds,
+        startedAt: result.startedAt,
+        completedAt: result.completedAt
+      });
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+async function getHistoryEntry(id) {
+  const filePath = join(HISTORY_DIR, `${id}.json`);
+  const raw = await readFile(filePath, "utf-8");
+  const result = JSON.parse(raw);
+  if (result.infographic && !result.infographics) {
+    result.infographics = [result.infographic];
+    delete result.infographic;
+  }
+  return result;
+}
+async function deleteHistoryEntry(id) {
+  const filePath = join(HISTORY_DIR, `${id}.json`);
+  await rm(filePath);
+}
+async function addInfographicToHistory(id, infographic) {
+  const filePath = join(HISTORY_DIR, `${id}.json`);
+  const raw = await readFile(filePath, "utf-8");
+  const result = JSON.parse(raw);
+  if (!result.infographics) result.infographics = [];
+  result.infographics.push(infographic);
+  await writeFile(filePath, JSON.stringify(result, null, 2), "utf-8");
+}
+async function deleteInfographicFromHistory(id, index) {
+  const filePath = join(HISTORY_DIR, `${id}.json`);
+  const raw = await readFile(filePath, "utf-8");
+  const result = JSON.parse(raw);
+  if (result.infographics && index >= 0 && index < result.infographics.length) {
+    result.infographics.splice(index, 1);
+  }
+  await writeFile(filePath, JSON.stringify(result, null, 2), "utf-8");
+}
+const require$1 = createRequire(import.meta.url);
+function buildPrompt(result) {
+  const names = result.counsellors.map((c) => c.name).join(", ");
+  const summary = result.summary ?? result.turns.map((t) => `${t.counsellorName}: ${t.content.slice(0, 200)}`).join("\n");
+  return [
+    "Create a professional infographic summarizing a panel discussion.",
+    `Topic: ${result.topic.slice(0, 300)}`,
+    `Key points: ${summary.slice(0, 1500)}`,
+    `Panelists: ${names}`,
+    "Use a clean, modern design with sections for convergence points, divergence points, and key takeaways.",
+    "Include relevant icons and visual hierarchy. Use a horizontal landscape layout."
+  ].join(" ");
+}
+function detectBackend(config) {
+  if (config.infographic?.backend) return config.infographic.backend;
+  const hasGoogle = !!(config.backends.google?.apiKey || process.env.GOOGLE_API_KEY);
+  const hasOpenai = !!(config.backends.openai?.apiKey || process.env.OPENAI_API_KEY);
+  if (hasGoogle) return "google";
+  if (hasOpenai) return "openai";
+  return null;
+}
+async function generateViaOpenAI(prompt, config) {
+  const OpenAI2 = require$1("openai").default;
+  const client = new OpenAI2({
+    apiKey: config.backends.openai?.apiKey || process.env.OPENAI_API_KEY,
+    ...config.backends.openai?.baseUrl ? { baseURL: config.backends.openai.baseUrl } : {}
+  });
+  const response = await client.images.generate({
+    model: "gpt-image-1",
+    prompt,
+    quality: "high",
+    size: "1536x1024"
+  });
+  const b64 = response.data?.[0]?.b64_json;
+  if (!b64) throw new Error("No image data returned from OpenAI");
+  return b64;
+}
+async function generateViaGoogle(prompt, config) {
+  const { GoogleGenAI } = require$1("@google/genai");
+  const apiKey = config.backends.google?.apiKey || process.env.GOOGLE_API_KEY;
+  if (!apiKey) throw new Error("No Google API key configured");
+  const ai = new GoogleGenAI({ apiKey });
+  const response = await ai.models.generateContent({
+    model: "gemini-3-pro-image-preview",
+    contents: prompt,
+    config: {
+      responseModalities: ["IMAGE", "TEXT"]
+    }
+  });
+  const parts = response.candidates?.[0]?.content?.parts;
+  if (!parts) throw new Error("No response parts from Gemini");
+  for (const part of parts) {
+    if (part.inlineData?.data) {
+      return part.inlineData.data;
+    }
+  }
+  throw new Error("No image data in Gemini response");
+}
+async function generateInfographic(result, config, backendOverride) {
+  const backend = backendOverride ?? detectBackend(config);
+  if (!backend) throw new Error("No image-capable backend configured (need OpenAI or Google API key)");
+  const prompt = buildPrompt(result);
+  if (backend === "openai") {
+    return generateViaOpenAI(prompt, config);
+  } else {
+    return generateViaGoogle(prompt, config);
+  }
+}
+const DEFAULT_URLS = {
+  anthropic: "https://api.anthropic.com",
+  openai: "https://api.openai.com/v1",
+  google: "https://generativelanguage.googleapis.com",
+  ollama: "http://localhost:11434"
+};
+const KNOWN_ANTHROPIC_MODELS = [
+  "claude-opus-4-20250514",
+  "claude-sonnet-4-5-20250514",
+  "claude-sonnet-4-20250514",
+  "claude-haiku-4-20250414",
+  "claude-3-5-haiku-20241022"
+];
+const KNOWN_GOOGLE_MODELS = [
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.0-flash",
+  "gemini-2.0-flash-lite",
+  "gemini-1.5-pro",
+  "gemini-1.5-flash"
+];
+async function probeBackend(name, config) {
+  try {
+    switch (name) {
+      case "ollama": {
+        const { Ollama: Ollama2 } = await import("ollama");
+        const client = new Ollama2({ host: config.baseUrl || DEFAULT_URLS.ollama });
+        const response = await client.list();
+        const models = response.models.map((m) => m.name).sort();
+        return { connected: true, models };
+      }
+      case "openai": {
+        const { default: OpenAI2 } = await import("openai");
+        const client = new OpenAI2({
+          apiKey: config.apiKey || process.env.OPENAI_API_KEY,
+          ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+        });
+        const response = await client.models.list();
+        const models = response.data.map((m) => m.id).filter((id) => id.startsWith("gpt-") || id.startsWith("o") || id.startsWith("chatgpt-")).sort();
+        return { connected: true, models };
+      }
+      case "anthropic": {
+        const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
+        const client = new Anthropic2({
+          apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
+          ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+        });
+        try {
+          const response = await client.models.list({ limit: 100 });
+          const models = response.data.map((m) => m.id).sort();
+          return { connected: true, models };
+        } catch {
+          return { connected: true, models: KNOWN_ANTHROPIC_MODELS };
+        }
+      }
+      case "google": {
+        const apiKey = config.apiKey || process.env.GOOGLE_API_KEY || "";
+        if (!apiKey) return { connected: false, models: KNOWN_GOOGLE_MODELS, error: "No API key" };
+        const res = await fetch(
+          `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+        );
+        if (!res.ok) {
+          const body = await res.json().catch(() => ({}));
+          const msg = body?.error?.message || `HTTP ${res.status}`;
+          return { connected: false, models: KNOWN_GOOGLE_MODELS, error: msg };
+        }
+        const data = await res.json();
+        const models = (data.models || []).filter((m) => m.name.includes("gemini") && m.supportedGenerationMethods?.includes("generateContent")).map((m) => m.name.replace("models/", "")).sort();
+        return { connected: true, models: models.length > 0 ? models : KNOWN_GOOGLE_MODELS };
+      }
+      default:
+        return { connected: false, models: [], error: `Unknown backend: ${name}` };
+    }
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    const fallbackModels = name === "anthropic" ? KNOWN_ANTHROPIC_MODELS : name === "google" ? KNOWN_GOOGLE_MODELS : [];
+    return { connected: false, models: fallbackModels, error };
+  }
+}
+let activeAbortController = null;
+let injectionBuffer = [];
+function registerIpcHandlers(ipcMain2, getWindow) {
+  ipcMain2.handle("counsellors:list", async (_event, councilDir) => {
+    const configPath = join(homedir(), ".ai-council", "config.json");
+    let config = { backends: {} };
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const registeredPaths = getRegisteredPaths(config);
+    const registry = config.counsellors ?? {};
+    const counsellors = await loadCounsellors(councilDir, registeredPaths);
+    return counsellors.map((c) => {
+      const regEntry = registry[c.id];
+      return {
+        id: c.id,
+        dirPath: c.dirPath,
+        name: c.frontmatter.name,
+        description: c.frontmatter.description,
+        backend: c.frontmatter.backend,
+        model: c.frontmatter.model,
+        temperature: c.frontmatter.temperature,
+        interests: c.frontmatter.interests,
+        avatarUrl: c.avatarUrl,
+        source: regEntry?.source,
+        registryUrl: regEntry?.url
+      };
+    });
+  });
+  ipcMain2.handle("counsellors:get", async (_event, dirPath) => {
+    const aboutPath = join(dirPath, "ABOUT.md");
+    const raw = await readFile(aboutPath, "utf-8");
+    const { data, content } = matter(raw);
+    return { frontmatter: data, body: content.trim(), raw };
+  });
+  ipcMain2.handle("counsellors:save", async (_event, dirPath, aboutMd) => {
+    const aboutPath = join(dirPath, "ABOUT.md");
+    await writeFile(aboutPath, aboutMd, "utf-8");
+    return { success: true };
+  });
+  ipcMain2.handle("counsellors:create", async (_event, councilDir, id, aboutMd) => {
+    const dirPath = join(councilDir, id);
+    await mkdir(dirPath, { recursive: true });
+    await writeFile(join(dirPath, "ABOUT.md"), aboutMd, "utf-8");
+    return { success: true, dirPath };
+  });
+  ipcMain2.handle("counsellors:delete", async (_event, dirPath) => {
+    await rm(dirPath, { recursive: true, force: true });
+    return { success: true };
+  });
+  ipcMain2.handle("config:get", async () => {
+    const configPath = join(homedir(), ".ai-council", "config.json");
+    let config = { backends: {} };
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const envStatus = {
+      ANTHROPIC_API_KEY: !!process.env.ANTHROPIC_API_KEY,
+      OPENAI_API_KEY: !!process.env.OPENAI_API_KEY,
+      GOOGLE_API_KEY: !!process.env.GOOGLE_API_KEY
+    };
+    const suffix = (key) => key ? "..." + key.slice(-4) : void 0;
+    const envKeySuffix = {
+      ANTHROPIC_API_KEY: suffix(process.env.ANTHROPIC_API_KEY),
+      OPENAI_API_KEY: suffix(process.env.OPENAI_API_KEY),
+      GOOGLE_API_KEY: suffix(process.env.GOOGLE_API_KEY)
+    };
+    return { config, envStatus, envKeySuffix, defaultUrls: DEFAULT_URLS };
+  });
+  ipcMain2.handle("backend:probe", async (_event, name, config) => {
+    return probeBackend(name, config);
+  });
+  ipcMain2.handle("config:save", async (_event, config) => {
+    const configDir = join(homedir(), ".ai-council");
+    await mkdir(configDir, { recursive: true });
+    await writeFile(join(configDir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+    clearCaches();
+    return { success: true };
+  });
+  ipcMain2.handle("discussion:start", async (_event, params) => {
+    const win = getWindow();
+    if (!win) return { error: "No window" };
+    if (activeAbortController) {
+      activeAbortController.abort();
+    }
+    activeAbortController = new AbortController();
+    injectionBuffer = [];
+    const configPath = join(homedir(), ".ai-council", "config.json");
+    let config = { backends: {} };
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const registeredPaths = getRegisteredPaths(config);
+    const allCounsellors = await loadCounsellors(params.councilDir, registeredPaths);
+    const counsellors = params.counsellorIds?.length ? allCounsellors.filter((c) => params.counsellorIds.includes(c.id)) : allCounsellors;
+    if (counsellors.length === 0) {
+      win.webContents.send("discussion:event", { type: "error", counsellorName: "", error: "No counsellors found" });
+      return;
+    }
+    const send = (event) => {
+      if (!win.isDestroyed()) {
+        win.webContents.send("discussion:event", event);
+      }
+    };
+    const beforeTurn = async () => {
+      if (injectionBuffer.length === 0) return null;
+      const content = injectionBuffer.shift();
+      return {
+        round: 0,
+        counsellorId: "__user__",
+        counsellorName: "You",
+        content,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        model: "human",
+        backend: "human"
+      };
+    };
+    const opts = {
+      topic: params.topic,
+      topicSource: params.topicSource,
+      counsellors,
+      rounds: params.rounds,
+      onEvent: send,
+      beforeTurn,
+      signal: activeAbortController.signal,
+      mode: params.mode,
+      config
+    };
+    try {
+      const result = await runConversation(opts);
+      if (config.secretary?.backend) {
+        try {
+          send({ type: "summary_start" });
+          const secretaryResult = await runSecretary({
+            result,
+            config,
+            onChunk: (delta) => {
+              send({ type: "summary_chunk", delta });
+            },
+            signal: activeAbortController?.signal
+          });
+          result.summary = secretaryResult.text;
+          if (secretaryResult.diagram) {
+            result.diagram = secretaryResult.diagram;
+          }
+          send({ type: "summary_complete", summary: secretaryResult.text, diagram: secretaryResult.diagram });
+        } catch (err) {
+          log$1.error("ipc:discussion", "Secretary summary failed", err);
+          send({ type: "error", counsellorName: "Secretary", error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      if (config.secretary?.backend) {
+        try {
+          const firstRoundTurns = result.turns.filter((t) => t.round === 1);
+          const title = await generateTitle({
+            topic: result.topic,
+            firstRoundTurns,
+            config
+          });
+          result.title = title;
+          send({ type: "title_generated", title });
+        } catch (err) {
+          log$1.error("ipc:discussion", "Title generation failed", err);
+        }
+      }
+      if (params.infographicBackends?.length) {
+        for (const backend of params.infographicBackends) {
+          try {
+            send({ type: "infographic_start" });
+            const infographicData = await generateInfographic(result, config, backend);
+            if (!result.infographics) result.infographics = [];
+            result.infographics.push(infographicData);
+            send({ type: "infographic_complete", infographic: infographicData });
+          } catch (err) {
+            log$1.error("ipc:discussion", `Infographic generation failed (${backend})`, err);
+            send({ type: "infographic_error", error: err instanceof Error ? err.message : String(err) });
+          }
+        }
+      }
+      send({ type: "complete", result });
+      try {
+        await saveToHistory(result);
+      } catch (err) {
+        log$1.error("ipc:discussion", "Failed to save to history", err);
+      }
+    } catch (err) {
+      log$1.error("ipc:discussion", "Discussion failed", err);
+      send({ type: "error", counsellorName: "", error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      activeAbortController = null;
+    }
+  });
+  ipcMain2.handle("discussion:stop", async () => {
+    if (activeAbortController) {
+      activeAbortController.abort();
+      activeAbortController = null;
+    }
+    return { success: true };
+  });
+  ipcMain2.handle("discussion:inject", async (_event, content) => {
+    injectionBuffer.push(content);
+    return { success: true };
+  });
+  ipcMain2.handle("registry:add-local", async (_event, dirPath) => {
+    return addLocalCounsellor(dirPath);
+  });
+  ipcMain2.handle("registry:add-remote", async (_event, url) => {
+    return addRemoteCounsellor(url);
+  });
+  ipcMain2.handle("registry:remove", async (_event, id, deleteFiles) => {
+    await removeCounsellor(id, deleteFiles);
+    return { success: true };
+  });
+  ipcMain2.handle("shell:open-in-finder", async (_event, dirPath) => {
+    shell.showItemInFolder(join(dirPath, "ABOUT.md"));
+  });
+  ipcMain2.handle("shell:open-in-terminal", async (_event, dirPath) => {
+    const execFileAsync2 = promisify(execFile);
+    await execFileAsync2("open", ["-a", "Terminal", dirPath]);
+  });
+  ipcMain2.handle("shell:open-in-editor", async (_event, dirPath) => {
+    const execFileAsync2 = promisify(execFile);
+    try {
+      await execFileAsync2("code", [dirPath]);
+    } catch {
+      shell.openPath(dirPath);
+    }
+  });
+  ipcMain2.handle("history:list", async () => listHistory());
+  ipcMain2.handle("history:get", async (_event, id) => getHistoryEntry(id));
+  ipcMain2.handle("history:delete", async (_event, id) => {
+    await deleteHistoryEntry(id);
+    return { success: true };
+  });
+  ipcMain2.handle("infographic:generate", async (_event, historyId, backend) => {
+    const configPath = join(homedir(), ".ai-council", "config.json");
+    let config = { backends: {} };
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const result = await getHistoryEntry(historyId);
+    const infographicData = await generateInfographic(result, config, backend);
+    await addInfographicToHistory(historyId, infographicData);
+    return { infographic: infographicData };
+  });
+  ipcMain2.handle("infographic:delete", async (_event, historyId, index) => {
+    await deleteInfographicFromHistory(historyId, index);
+    return { success: true };
+  });
+  ipcMain2.handle("file:read-as-text", async (_event, filePath) => {
+    const name = basename(filePath);
+    const ext = name.includes(".") ? "." + name.split(".").pop().toLowerCase() : "";
+    const textExtensions = /* @__PURE__ */ new Set([
+      ".txt",
+      ".md",
+      ".csv",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".xml",
+      ".html",
+      ".htm",
+      ".js",
+      ".ts",
+      ".jsx",
+      ".tsx",
+      ".py",
+      ".rb",
+      ".go",
+      ".rs",
+      ".java",
+      ".c",
+      ".cpp",
+      ".h",
+      ".hpp",
+      ".css",
+      ".scss",
+      ".less",
+      ".sql",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".env",
+      ".toml",
+      ".ini",
+      ".cfg",
+      ".conf",
+      ".log",
+      ".svg"
+    ]);
+    const markitdownExtensions = /* @__PURE__ */ new Set([
+      ".pdf",
+      ".docx",
+      ".pptx",
+      ".xlsx",
+      ".xls",
+      ".doc",
+      ".ppt",
+      ".epub",
+      ".rtf"
+    ]);
+    if (textExtensions.has(ext)) {
+      try {
+        const content = await readFile(filePath, "utf-8");
+        return { name, content };
+      } catch (err) {
+        return { name, content: `[Error reading file: ${err instanceof Error ? err.message : String(err)}]` };
+      }
+    }
+    if (markitdownExtensions.has(ext)) {
+      const execFileAsync2 = promisify(execFile);
+      try {
+        const { stdout } = await execFileAsync2("markitdown", [filePath], {
+          timeout: 3e4,
+          maxBuffer: 10 * 1024 * 1024
+          // 10 MB
+        });
+        return { name, content: stdout };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("ENOENT")) {
+          return {
+            name,
+            content: `[Cannot convert ${ext} file: markitdown is not installed. Run: pip install 'markitdown[all]']`
+          };
+        }
+        return { name, content: `[Error converting file: ${msg}]` };
+      }
+    }
+    return { name, content: `[Unsupported file type: ${name}]` };
+  });
+  ipcMain2.handle("markitdown:check", async () => {
+    const execFileAsync2 = promisify(execFile);
+    try {
+      const { stdout } = await execFileAsync2("markitdown", ["--version"], { timeout: 5e3 });
+      return { installed: true, version: stdout.trim() };
+    } catch {
+      return { installed: false };
+    }
+  });
+  ipcMain2.handle("markitdown:install", async () => {
+    const execFileAsync2 = promisify(execFile);
+    try {
+      await execFileAsync2("pip", ["install", "markitdown[all]"], {
+        timeout: 12e4,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+  ipcMain2.handle("dialog:selectDirectory", async () => {
+    const win = getWindow();
+    if (!win) return null;
+    const result = await dialog.showOpenDialog(win, {
+      properties: ["openDirectory"]
+    });
+    return result.canceled ? null : result.filePaths[0];
+  });
+}
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+const logFile = join(__dirname$1, "..", "electron-debug.log");
+function log(source, ...args) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${source}] ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+  appendFileSync(logFile, line);
+}
+writeFileSync(logFile, `=== AI Council Electron — started ${(/* @__PURE__ */ new Date()).toISOString()} ===
+`);
+let mainWindow = null;
+function createWindow() {
+  log("main", "Creating BrowserWindow");
+  mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    minWidth: 800,
+    minHeight: 600,
+    title: "AI Council",
+    webPreferences: {
+      contextIsolation: true,
+      nodeIntegration: false,
+      preload: join(__dirname$1, "preload.mjs")
+    }
+  });
+  mainWindow.webContents.on("console-message", (_event, level, message, line, sourceId) => {
+    const levelName = ["DEBUG", "INFO", "WARN", "ERROR"][level] || "LOG";
+    log(`renderer:${levelName}`, `${message} (${sourceId}:${line})`);
+  });
+  mainWindow.webContents.on("render-process-gone", (_event, details) => {
+    log("main:CRASH", "Renderer process gone:", details);
+  });
+  mainWindow.webContents.on("did-fail-load", (_event, errorCode, errorDescription) => {
+    log("main:LOAD_ERROR", `Failed to load: ${errorCode} ${errorDescription}`);
+  });
+  const url = process.env.VITE_DEV_SERVER_URL;
+  if (url) {
+    log("main", `Loading dev server URL: ${url}`);
+    mainWindow.loadURL(url);
+  } else {
+    const filePath = join(__dirname$1, "../dist-renderer/index.html");
+    log("main", `Loading file: ${filePath}`);
+    mainWindow.loadFile(filePath);
+  }
+  if (process.env.VITE_DEV_SERVER_URL) {
+    mainWindow.webContents.openDevTools();
+  }
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+}
+protocol.registerSchemesAsPrivileged([
+  { scheme: "council-file", privileges: { bypassCSP: true, supportFetchAPI: true } }
+]);
+app.whenReady().then(() => {
+  log("main", "App ready, registering IPC handlers");
+  protocol.handle("council-file", (request) => {
+    const filePath = decodeURIComponent(request.url.replace("council-file://", ""));
+    return net.fetch(pathToFileURL(filePath).href);
+  });
+  registerIpcHandlers(ipcMain, () => mainWindow);
+  createWindow();
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});