server.ts

import express from "express";
import path from "path";
import fs from "fs";
import os from "os";
import net from "net";
import crypto from "crypto";
import dotenv from "dotenv";
import { createServer as createViteServer } from "vite";
import { GoogleGenAI, Type } from "@google/genai";

// Load environment variables. override:true makes .env authoritative over
// inherited shell/machine env vars — without it, a stale system-level key
// (e.g. an exhausted OPENAI_API_KEY set in Windows) silently beats a fresh
// one in .env, because dotenv's default is to NOT overwrite existing vars.
dotenv.config({ override: true });

// --- Run persistence ---------------------------------------------------------
// Finished research must never depend on a browser tab surviving: a synthesis
// run persists its INPUTS (all specialist reports) the moment the request
// arrives and its OUTPUT the moment generation completes, under
// runs/<timestamp>-<topic-slug>/. Best-effort by design — a disk failure logs
// a warning and the pipeline continues.
const RUNS_DIR = path.join(process.cwd(), "runs");
// Generated agent portraits (gitignored). See /api/research/agent-portrait.
const PORTRAITS_DIR = path.join(process.cwd(), "portraits");
const PORTRAIT_MODEL = process.env.PORTRAIT_MODEL || "gemini-3.1-flash-image";
const PORTRAIT_ACCENTS: Record<string, string> = {
  cyan: "cyan", emerald: "emerald green", rose: "rose pink", amber: "amber", purple: "violet", indigo: "indigo", blue: "electric blue", fuchsia: "magenta",
};
const slugify = (s: string) =>
  String(s).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "run";
const persistRunFile = (runDir: string, name: string, data: string) => {
  try {
    fs.mkdirSync(runDir, { recursive: true });
    fs.writeFileSync(path.join(runDir, name), data, "utf8");
  } catch (e: any) {
    console.warn(`Run persistence failed (${name}): ${e?.message || e}`);
  }
};

// Validate Gemini API Key
const apiKey = process.env.GEMINI_API_KEY;
if (!apiKey) {
  console.warn("WARNING: GEMINI_API_KEY environment variable is not set. Gemini API calls will fail.");
}

// Initialize Gemini Client
const ai = new GoogleGenAI({
  apiKey: apiKey,
  httpOptions: {
    headers: {
      "User-Agent": "aistudio-build",
    },
  },
});

const generateWithRetry = async (params: any, retries = 4, baseDelayMs = 15000): Promise<any> => {
  for (let i = 0; i < retries; i++) {
    try {
      return await ai.models.generateContent(params);
    } catch (error: any) {
      const isRateLimitOrOverload = 
        error?.status === 429 || 
        error?.status === 503 || 
        error?.status === 'RESOURCE_EXHAUSTED' ||
        error?.message?.includes('429') ||
        error?.message?.includes('503') ||
        error?.message?.includes('quota');

      if (i < retries - 1 && isRateLimitOrOverload) {
        // Look for a retry delay in the error if provided, otherwise fallback to exponential backoff with random jitter
        let delay = baseDelayMs * Math.pow(1.5, i) + Math.floor(Math.random() * 4000);
        if (error?.message) {
          const match = error.message.match(/Please retry in ([\d.]+)s/);
          if (match && match[1]) {
            delay = (parseFloat(match[1]) * 1000) + 1500; // Add 1.5s buffer
          }
        }
        
        console.warn(`[API] Rate limit/Overload encountered. Retrying in ${delay}ms... (Attempt ${i + 1} of ${retries})`);
        await new Promise(res => setTimeout(res, delay));
      } else {
        throw error;
      }
    }
  }
};

const generateStreamWithRetry = async (params: any, retries = 4, baseDelayMs = 15000): Promise<any> => {
  for (let i = 0; i < retries; i++) {
    try {
      const responseStream = await ai.models.generateContentStream(params);
      // Wait for the first chunk to ensure the stream actually starts and we catch early rate limit errors
      const iterator = responseStream[Symbol.asyncIterator]();
      const firstChunk = await iterator.next();
      
      // If we get here, it succeeded. We create a generator to yield the first chunk then the rest
      async function* wrappedStream() {
        if (!firstChunk.done) {
          yield firstChunk.value;
          yield* iterator;
        }
      }
      return wrappedStream();
    } catch (error: any) {
      const isRateLimitOrOverload = 
        error?.status === 429 || 
        error?.status === 503 || 
        error?.status === 'RESOURCE_EXHAUSTED' ||
        error?.message?.includes('429') ||
        error?.message?.includes('503') ||
        error?.message?.includes('quota');

      if (i < retries - 1 && isRateLimitOrOverload) {
        let delay = baseDelayMs * Math.pow(1.5, i) + Math.floor(Math.random() * 4000);
        if (error?.message) {
          const match = error.message.match(/Please retry in ([\d.]+)s/);
          if (match && match[1]) {
            delay = (parseFloat(match[1]) * 1000) + 1500; // Add 1.5s buffer
          }
        }
        
        console.warn(`[API Stream] Rate limit/Overload encountered. Retrying in ${delay}ms... (Attempt ${i + 1} of ${retries})`);
        await new Promise(res => setTimeout(res, delay));
      } else {
        throw error;
      }
    }
  }
};

// -------------------------------------------------------------
// Universal Multi-Provider Routing & LLM Execution Helpers
// -------------------------------------------------------------

// Parses the FIRST balanced JSON object/array starting at the first opening
// char — rescues responses where the model emits valid JSON followed by
// trailing prose or a second JSON blob.
function parseFirstBalanced(text: string, openChar: "{" | "[", closeChar: "}" | "]"): any | null {
  const start = text.indexOf(openChar);
  if (start === -1) return null;
  let depth = 0;
  let inString = false;
  let escaped = false;
  for (let i = start; i < text.length; i++) {
    const ch = text[i];
    if (inString) {
      if (escaped) escaped = false;
      else if (ch === "\\") escaped = true;
      else if (ch === '"') inString = false;
      continue;
    }
    if (ch === '"') { inString = true; continue; }
    if (ch === openChar) depth++;
    else if (ch === closeChar) {
      depth--;
      if (depth === 0) {
        try {
          return JSON.parse(text.slice(start, i + 1));
        } catch (e) {
          return null;
        }
      }
    }
  }
  return null;
}

function extractJSON(text: string): any {
  let cleanText = text.replace(/```json/gi, "").replace(/```/g, "").trim();
  try {
    return JSON.parse(cleanText);
  } catch (e) {
    const firstBrace = cleanText.indexOf("{");
    const firstBracket = cleanText.indexOf("[");

    let startIdx = -1;
    let endIdx = -1;

    if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
      startIdx = firstBrace;
      endIdx = cleanText.lastIndexOf("}");
    } else if (firstBracket !== -1) {
      startIdx = firstBracket;
      endIdx = cleanText.lastIndexOf("]");
    }

    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
      const JSONStr = cleanText.substring(startIdx, endIdx + 1);
      try {
        return JSON.parse(JSONStr);
      } catch (innerError: any) {
        const balanced = parseFirstBalanced(cleanText, "{", "}") ?? parseFirstBalanced(cleanText, "[", "]");
        if (balanced !== null) return balanced;
        throw new Error(`Candidate JSON located but parsing failed: ${innerError.message}. Content: ${JSONStr.slice(0, 600)}`);
      }
    }
    throw new Error(`Failed to locate any valid JSON array or block in model response: ${text.slice(0, 600)}`);
  }
}

// .env keys are the durable option — browser-stored keys are per-origin
// (host:port) and vanish whenever the port changes.
function envKeyFor(provider: string): string {
  const envKeys: Record<string, string> = {
    gemini: process.env.GEMINI_API_KEY || "",
    openrouter: process.env.OPENROUTER_API_KEY || "",
    openai: process.env.OPENAI_API_KEY || "",
    anthropic: process.env.ANTHROPIC_API_KEY || "",
    venice: process.env.VENICE_API_KEY || "",
  };
  return envKeys[provider] || "";
}

// The three pipeline roles plus "forge": the model that writes reusable
// personas for the Agent Library. Forge falls back to the orchestrator
// mapping when the client has not set one.
type TaskRole = "orchestrator" | "agent" | "synthesis" | "forge";

function getModelAndKey(taskRole: TaskRole, settings: any) {
  let provider = "gemini";
  let model = "gemini-3.5-flash";
  let apiKey = "";
  let baseUrl = "";

  const mappingKey: TaskRole = taskRole === "forge" && !(settings?.modelMapping?.forge?.model) ? "orchestrator" : taskRole;
  if (settings && settings.modelMapping && settings.modelMapping[mappingKey]) {
    const mapping = settings.modelMapping[mappingKey];
    provider = mapping.provider || "gemini";
    model = mapping.model || "gemini-3.5-flash";

    if (settings.providers && settings.providers[provider]) {
      const prov = settings.providers[provider];
      apiKey = prov.apiKey || "";
      baseUrl = prov.baseUrl || "";
    }
  }

  if (!apiKey) {
    apiKey = envKeyFor(provider);
  }
  if (!baseUrl) {
    if (provider === "lmstudio") baseUrl = process.env.LMSTUDIO_BASE_URL || "http://localhost:1234/v1";
    else if (provider === "ollama") baseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
  }

  return { provider, model, apiKey, baseUrl };
}

// Non-streaming JSON calls MUST time out: a congested provider (e.g. a
// brand-new model being hammered on OpenRouter) can otherwise hold the
// connection open indefinitely, hanging the whole pipeline at "assembling"
// with no error and no retry. 180s accommodates slow reasoning models.
const JSON_CALL_TIMEOUT_MS = 180000;

async function callOpenAICompatible(url: string, apiKey: string, body: any): Promise<any> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), JSON_CALL_TIMEOUT_MS);
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        ...(apiKey ? { "Authorization": `Bearer ${apiKey}` } : {})
      },
      body: JSON.stringify(body),
      signal: controller.signal
    });
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Upstream API status ${response.status}: ${errorText || response.statusText}`);
    }
    return await response.json();
  } catch (err: any) {
    if (err?.name === "AbortError") {
      throw new Error(`Upstream request timed out after ${JSON_CALL_TIMEOUT_MS / 1000}s (${url}) — the provider may be overloaded; retry or switch models.`);
    }
    throw err;
  } finally {
    clearTimeout(timer);
  }
}

async function callAnthropic(apiKey: string, body: any): Promise<any> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), JSON_CALL_TIMEOUT_MS);
  try {
    const response = await fetch("https://api.anthropic.com/v1/messages", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": apiKey,
        "anthropic-version": "2023-06-01"
      },
      body: JSON.stringify(body),
      signal: controller.signal
    });
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Anthropic API status ${response.status}: ${errorText || response.statusText}`);
    }
    return await response.json();
  } catch (err: any) {
    if (err?.name === "AbortError") {
      throw new Error(`Anthropic request timed out after ${JSON_CALL_TIMEOUT_MS / 1000}s — the provider may be overloaded; retry or switch models.`);
    }
    throw err;
  } finally {
    clearTimeout(timer);
  }
}

// -------------------------------------------------------------
// Live Web Grounding
// -------------------------------------------------------------
// Gemini, Anthropic, OpenRouter, and Venice can run real web search natively,
// so hasSearch is wired into their request bodies. Every other provider
// (LM Studio, Ollama, plain OpenAI chat) has no live internet access — for
// those the server runs SearXNG queries itself and injects the results into
// the prompt, otherwise the model silently answers from stale training data
// while claiming to have "searched".

const SEARXNG_BASE_URL = (process.env.SEARXNG_BASE_URL || "http://localhost:8888").replace(/\/$/, "");

// Optional API fallbacks for when SearXNG is unreachable or returns nothing.
// Leave the env vars unset to disable an engine.
const BRAVE_SEARCH_API_KEY = process.env.BRAVE_SEARCH_API_KEY || "";
const TAVILY_API_KEY = process.env.TAVILY_API_KEY || "";

const NATIVE_SEARCH_PROVIDERS = new Set(["gemini", "anthropic", "openrouter", "venice"]);

// Providers whose native search is genuinely agentic (the model iterates its
// own real queries). Everyone else gets the server-side injected block —
// including OpenRouter/Venice, whose web plugins auto-derive a single query
// from the prompt and miss niche exact-phrase targets.
const AGENTIC_SEARCH_PROVIDERS = new Set(["gemini", "anthropic"]);

interface SearchHit {
  title: string;
  url: string;
  snippet: string;
  publishedDate?: string;
  fromNews?: boolean;
}

async function searxngSearch(query: string, maxResults = 10, category?: string): Promise<SearchHit[]> {
  const catParam = category ? `&categories=${encodeURIComponent(category)}` : "";
  const url = `${SEARXNG_BASE_URL}/search?q=${encodeURIComponent(query)}&format=json${catParam}`;
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 20000);
  try {
    const response = await fetch(url, { signal: controller.signal });
    if (!response.ok) throw new Error(`SearXNG responded with status ${response.status}`);
    const data = await response.json() as any;
    return (data.results || []).slice(0, maxResults).map((r: any) => ({
      title: r.title || "(untitled)",
      url: r.url || "",
      snippet: (r.content || "").slice(0, 500),
      publishedDate: typeof r.publishedDate === "string" ? r.publishedDate.slice(0, 10) : undefined,
      fromNews: category === "news",
    }));
  } finally {
    clearTimeout(timer);
  }
}

// Mechanical query variants: exact quoted phrase and de-glued identifiers
// (DUDE44BRAVO -> DUDE 44 BRAVO). These guarantee a niche exact-phrase target
// still gets hunted even when the LLM query planner fails or under-delivers.
function buildQueryVariants(topic: string): string[] {
  const variants = new Set<string>();
  const t = topic.trim().slice(0, 120);
  if (!t) return [];
  variants.add(t);
  const spaced = t.replace(/([A-Za-z])(\d)/g, "$1 $2").replace(/(\d)([A-Za-z])/g, "$1 $2");
  if (spaced !== t) variants.add(spaced);
  if (t.length <= 60 && !t.includes('"')) variants.add(`"${t}"`);
  if (spaced !== t && spaced.length <= 60) variants.add(`"${spaced}"`);
  return [...variants];
}

const QUERY_STOPWORDS = new Set(["the", "and", "for", "with", "that", "this", "from", "what", "who", "how", "are", "was", "were", "latest", "news", "about", "into", "over", "under", "when", "where", "which", "does", "did", "has", "have", "its", "their", "your", "our", "not", "all", "any", "site", "org", "com"]);

// Rank hits by overlap with the queries' distinctive terms so junk from noisy
// engines sinks instead of crowding real coverage out of the context block.
function rankHits(hits: SearchHit[], queries: string[]): SearchHit[] {
  const terms = new Set<string>();
  for (const q of queries) {
    for (const w of q.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/)) {
      if (w.length >= 2 && !QUERY_STOPWORDS.has(w)) terms.add(w);
    }
  }
  const scored = hits.map((h) => {
    const text = `${h.title} ${h.snippet}`.toLowerCase();
    let score = 0;
    for (const term of terms) if (text.includes(term)) score++;
    if (h.fromNews) score += 1;
    return { h, score };
  });
  scored.sort((a, b) => b.score - a.score);
  // When enough hits genuinely match, drop the zero-overlap junk entirely.
  const matching = scored.filter((s) => s.score >= 2);
  return (matching.length >= 5 ? matching : scored).map((s) => s.h);
}

async function braveSearch(query: string, maxResults = 8): Promise<SearchHit[]> {
  const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`;
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 15000);
  try {
    const response = await fetch(url, {
      headers: { "Accept": "application/json", "X-Subscription-Token": BRAVE_SEARCH_API_KEY },
      signal: controller.signal,
    });
    if (!response.ok) throw new Error(`Brave responded with status ${response.status}`);
    const data = await response.json() as any;
    return (data.web?.results || []).slice(0, maxResults).map((r: any) => ({
      title: r.title || "(untitled)",
      url: r.url || "",
      snippet: (r.description || "").slice(0, 500),
    }));
  } finally {
    clearTimeout(timer);
  }
}

async function tavilySearch(query: string, maxResults = 8): Promise<SearchHit[]> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 15000);
  try {
    const response = await fetch("https://api.tavily.com/search", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ api_key: TAVILY_API_KEY, query, max_results: maxResults }),
      signal: controller.signal,
    });
    if (!response.ok) throw new Error(`Tavily responded with status ${response.status}`);
    const data = await response.json() as any;
    return (data.results || []).slice(0, maxResults).map((r: any) => ({
      title: r.title || "(untitled)",
      url: r.url || "",
      snippet: (r.content || "").slice(0, 500),
    }));
  } finally {
    clearTimeout(timer);
  }
}

// Crude but dependency-free HTML→text extraction for full-article reading.
// Good enough to hand a model the body text of a news article or blog post.
function htmlToText(html: string): string {
  let s = html
    .replace(/<script[\s\S]*?<\/script>/gi, " ")
    .replace(/<style[\s\S]*?<\/style>/gi, " ")
    .replace(/<noscript[\s\S]*?<\/noscript>/gi, " ")
    .replace(/<!--[\s\S]*?-->/g, " ")
    .replace(/<(nav|header|footer|aside|form)[\s\S]*?<\/\1>/gi, " ");
  s = s.replace(/<(br|p|div|li|h[1-6]|tr|section|article)[^>]*>/gi, "\n");
  s = s.replace(/<[^>]+>/g, " ");
  s = s
    .replace(/&nbsp;/g, " ")
    .replace(/&amp;/g, "&")
    .replace(/&lt;/g, "<")
    .replace(/&gt;/g, ">")
    .replace(/&quot;/g, '"')
    .replace(/&#0?39;/g, "'")
    .replace(/&#\d+;/g, " ");
  return s.replace(/[ \t]+/g, " ").replace(/\s*\n\s*/g, "\n").replace(/\n{2,}/g, "\n").trim();
}

async function fetchPageExtract(url: string, maxChars = 6000): Promise<string | null> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 12000);
  try {
    const response = await fetch(url, {
      signal: controller.signal,
      redirect: "follow",
      headers: {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) SwarmIntel/1.0 research assistant",
        "Accept": "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.5",
      },
    });
    if (!response.ok) return null;
    const ctype = response.headers.get("content-type") || "";
    if (!ctype.includes("text/html") && !ctype.includes("text/plain") && !ctype.includes("application/xhtml")) return null;
    const raw = (await response.text()).slice(0, 600_000);
    const text = ctype.includes("text/plain") ? raw : htmlToText(raw);
    // Paywalls and JS shells extract to almost nothing — not worth injecting.
    if (text.length < 300) return null;
    return text.slice(0, maxChars);
  } catch (e) {
    return null;
  } finally {
    clearTimeout(timer);
  }
}

// How many top-ranked pages get fetched and text-extracted per grounding run.
// Generous by design — local models with 1M+ contexts thrive on more.
const FULL_PAGE_EXTRACT_COUNT = 10;

// Runs all queries in parallel against an engine chain — SearXNG first (free,
// aggregates many engines; queried in BOTH the general and news categories,
// because the general category's engine soup buries current events that the
// news category surfaces cleanly), then any configured API fallbacks. The
// first engine that returns hits wins; `engine` reports which one grounded
// the run. Hits are relevance-ranked, the top few pages are fetched in full
// and text-extracted so agents read complete articles instead of snippets,
// and the block states exactly which queries were executed so agents can
// report methodology honestly.
async function gatherLiveContext(
  queries: string[],
  refine?: (digest: string, alreadyRun: string[]) => Promise<string[]>,
  onStage?: (s: StageInfo) => void,
  // The news-category doubling was a junk-filter fix for SearXNG's general
  // category. Under a fringe-first evidence policy it is OFF: the server must
  // not inject mainstream press on every wave while the prompt asks for
  // archives and practitioner lanes. Search mix is code, not a sentence.
  newsLane: boolean = true
): Promise<{ block: string; hitCount: number; engine: string; pages: number; waves: number; urls: string[]; extractedUrls: string[]; queries: string[] }> {
  const uniqueQueries = [...new Set(queries.map((q) => q.trim()).filter(Boolean))].slice(0, 10);

  const engines: { name: string; enabled: boolean; sequentialDelayMs?: number; jobsFor: (qs: string[]) => { query: string; run: () => Promise<SearchHit[]> }[] }[] = [
    {
      name: "SearXNG",
      enabled: true,
      jobsFor: (qs) => qs.flatMap((q) => newsLane
        ? [
            { query: q, run: () => searxngSearch(q, 10) },
            { query: q, run: () => searxngSearch(q, 10, "news") },
          ]
        : [{ query: q, run: () => searxngSearch(q, 10) }]),
    },
    {
      // Brave's free tier allows one request per second; firing a wave in
      // parallel returns 429 for everything after the first.
      name: "Brave",
      enabled: !!BRAVE_SEARCH_API_KEY,
      sequentialDelayMs: 1100,
      jobsFor: (qs) => qs.map((q) => ({ query: q, run: () => braveSearch(q) })),
    },
    {
      name: "Tavily",
      enabled: !!TAVILY_API_KEY,
      jobsFor: (qs) => qs.map((q) => ({ query: q, run: () => tavilySearch(q) })),
    },
  ];

  for (const engine of engines) {
    if (!engine.enabled) continue;
    const seen = new Set<string>();
    const hits: SearchHit[] = [];
    const perQuery = new Map<string, number>();
    // Queries for which at least one job actually completed. A query that
    // only failed (engine down, rate-limited) must be reported to the model
    // as NOT RUN — never as "0 results", which reads as evidence of absence.
    const succeeded = new Set<string>();

    const runWave = async (waveQueries: string[]) => {
      const jobs = engine.jobsFor(waveQueries);
      let settled: PromiseSettledResult<SearchHit[]>[];
      if (engine.sequentialDelayMs) {
        settled = [];
        for (let i = 0; i < jobs.length; i++) {
          if (i > 0) await new Promise((r) => setTimeout(r, engine.sequentialDelayMs));
          settled.push(...(await Promise.allSettled([jobs[i].run()])));
        }
      } else {
        settled = await Promise.allSettled(jobs.map((j) => j.run()));
      }
      settled.forEach((result, idx) => {
        const job = jobs[idx];
        if (result.status !== "fulfilled") {
          console.warn(`[Grounding] ${engine.name} query failed ("${job.query.slice(0, 60)}"): ${result.reason?.message || result.reason}`);
          return;
        }
        succeeded.add(job.query);
        perQuery.set(job.query, (perQuery.get(job.query) || 0) + result.value.length);
        for (const hit of result.value) {
          if (!hit.url || seen.has(hit.url)) continue;
          seen.add(hit.url);
          hits.push(hit);
        }
      });
    };

    // Wave 1 — landscape survey.
    onStage?.({ stage: "searching", wave: 1 });
    await runWave(uniqueQueries);

    // Wave 2 — iterative deepening: queries written FROM what wave 1 actually
    // returned (chase discovered entities, hunt counter-evidence, fill gaps).
    let allQueries = [...uniqueQueries];
    let waves = 1;
    if (refine && hits.length > 0) {
      try {
        const digest = rankHits(hits, uniqueQueries)
          .slice(0, 15)
          .map((h) => `- ${h.title} :: ${h.snippet.slice(0, 160)}`)
          .join("\n");
        const followups = (await refine(digest, uniqueQueries))
          .map((q) => q.trim())
          .filter((q) => q && !allQueries.some((prev) => prev.toLowerCase() === q.toLowerCase()))
          .slice(0, 6);
        if (followups.length > 0) {
          console.log(`[Grounding] Wave 2 (${engine.name}): ${followups.map((q) => `"${q}"`).join(" | ")}`);
          onStage?.({ stage: "searching", wave: 2, hits: hits.length });
          await runWave(followups);
          allQueries = [...allQueries, ...followups];
          waves = 2;
        }
      } catch (err: any) {
        console.warn(`[Grounding] Wave 2 refinement failed: ${err?.message || err}`);
      }
    }

    if (hits.length > 0) {
      const ranked = rankHits(hits, allQueries).slice(0, 40);
      const today = new Date().toISOString().slice(0, 10);
      const queryLines = allQueries
        .map((q, i) => succeeded.has(q)
          ? `- [wave ${i < uniqueQueries.length ? 1 : 2}] "${q}" (${perQuery.get(q) || 0} raw hits)`
          : `- [wave ${i < uniqueQueries.length ? 1 : 2}] "${q}" — SEARCH FAILED (engine error): this query did NOT run. Treat it as unsearched; it is NOT evidence that nothing exists.`)
        .join("\n");
      const lines = ranked.map(
        (h, i) => `[${i + 1}] ${h.title}${h.publishedDate ? ` (published ${h.publishedDate})` : ""}\n    URL: ${h.url}\n    ${h.snippet}`
      );

      // Full-article reading: fetch the top-ranked pages and hand the agent
      // real body text, not just search snippets.
      const toFetch = ranked.slice(0, FULL_PAGE_EXTRACT_COUNT);
      onStage?.({ stage: "reading", pages: toFetch.length, hits: ranked.length });
      const extractResults = await Promise.allSettled(toFetch.map((h) => fetchPageExtract(h.url)));
      const extracts: string[] = [];
      const extractedUrls: string[] = [];
      extractResults.forEach((result, idx) => {
        if (result.status === "fulfilled" && result.value) {
          extractedUrls.push(toFetch[idx].url);
          extracts.push(`=== FULL TEXT of [${idx + 1}] ${toFetch[idx].title}\n    URL: ${toFetch[idx].url}\n${result.value}`);
        }
      });

      const extractsSection = extracts.length > 0
        ? `\n\nFULL SOURCE EXTRACTS (complete body text fetched from the top-ranked sources — quote and verify against THESE, not just the snippets):\n${extracts.join("\n\n")}`
        : "";

      const block = `LIVE WEB SEARCH RESULTS (retrieved ${today} UTC via ${engine.name} — current, real-world data)
Searched in ${waves === 2 ? "TWO waves: a landscape survey, then a deepening wave whose queries were written from what the first wave actually returned" : "a single landscape wave"}.
Queries the research system executed on your behalf (these are the ONLY searches run for you):
${queryLines}

Results (deduplicated, relevance-ranked):
${lines.join("\n")}${extractsSection}`;
      return { block, hitCount: ranked.length, engine: engine.name, pages: extracts.length, waves, urls: ranked.map((h) => h.url), extractedUrls, queries: allQueries };
    }
    console.warn(`[Grounding] ${engine.name} returned no hits${engine.name === "SearXNG" ? ` (${SEARXNG_BASE_URL})` : ""} — trying next engine.`);
  }
  return { block: "", hitCount: 0, engine: "none", pages: 0, waves: 0, urls: [], extractedUrls: [], queries: [] };
}

// Normalize a URL for "already in hand" comparisons between the injected
// SearXNG set and what a provider's native search tool brings back.
const normUrl = (u: string): string =>
  String(u || "").trim().replace(/^https?:\/\//i, "").replace(/^www\./i, "").replace(/[#?].*$/, "").replace(/\/+$/, "").toLowerCase();

// Iterative deepening (k-deep-research "progressive refinement"): wave 2's
// queries are written FROM wave 1's actual results — chasing the specific
// entities that surfaced, hunting counter-evidence, and filling visible gaps.
async function refineQueriesFromResults(
  settings: any,
  digest: string,
  alreadyRun: string[]
): Promise<string[]> {
  const schema = {
    type: Type.OBJECT,
    properties: {
      queries: { type: Type.ARRAY, description: "4-6 follow-up search queries", items: { type: Type.STRING } },
    },
    required: ["queries"],
  };
  const prompt = `A first wave of web searches has returned. Your job is to write the SECOND wave.

QUERIES ALREADY RUN (do not repeat these):
${alreadyRun.map((q) => `- ${q}`).join("\n")}

WHAT WAVE 1 RETURNED (titles :: snippets):
${digest}

Write 4-6 NEW search queries that deepen this investigation. Mandatory coverage:
- CHASE SPECIFICS: name the concrete entities that actually appeared above — people, organizations, documents, products, place names, dates, case numbers — and search for them directly.
- HUNT COUNTER-EVIDENCE: at least one query aimed at critique, rebuttal, debunking, or the dissenting view of the dominant claim above.
- FOLLOW THE INCENTIVE: at least one query about who funds, benefits from, or is harmed by the dominant narrative above.
- FILL THE GAP: target what wave 1 conspicuously did NOT answer.
Each query is a tight search-engine string of 2-8 words, not a sentence or question. Return only JSON: {"queries": ["...", "..."]}.`;

  const result = await generateUnifiedJSON(
    "orchestrator",
    settings,
    prompt,
    "You are a research query strategist running the deepening pass of an investigation. Output only the JSON object.",
    schema
  );
  return Array.isArray(result?.queries)
    ? result.queries.filter((q: any) => typeof q === "string" && q.trim()).map((q: string) => q.trim().slice(0, 140))
    : [];
}

export interface GroundingInfo {
  mode: "native" | "injected" | "none";
  detail: string;
}

// Real pipeline stage telemetry, streamed to the client as SSE `stage`
// events so the UI shows what an agent is actually doing instead of a
// simulated progress bar.
export interface StageInfo {
  stage: "planning" | "searching" | "reading" | "reasoning" | "writing";
  wave?: number;
  pages?: number;
  hits?: number;
}

// -------------------------------------------------------------
// Follow-Up Runs
// -------------------------------------------------------------
// A follow-up session carries condensed context from its parent run so the
// orchestrator targets the gaps and agents build on established findings
// instead of re-deriving them.

function formatPriorContextBlock(priorContext: any): string {
  if (!priorContext || typeof priorContext !== "object") return "";
  const synthesis = String(priorContext.synthesis || "").slice(0, 24000);
  const chatExcerpt = String(priorContext.chatExcerpt || "").slice(0, 8000);
  const directive = String(priorContext.directive || "").trim();
  const parentTopic = String(priorContext.parentTopic || "").trim();
  if (!synthesis && !directive) return "";

  // Fringe case files carry their unworked leads forward so follow-up swarms
  // work the case instead of restarting it.
  const openLeads = Array.isArray(priorContext.leads)
    ? priorContext.leads.filter((l: any) => l && l.status === "open" && typeof l.text === "string")
    : [];
  const leadsBlock = openLeads.length
    ? `\nOPEN LEADS ON FILE (unworked threads from the prior investigation — prioritize these):\n${openLeads.map((l: any) => `- [${l.id}] ${l.text}`).join("\n")}\n`
    : "";

  return `PRIOR INVESTIGATION CONTEXT (this is a FOLLOW-UP run — an earlier swarm already researched the topic below):
ORIGINAL TOPIC: "${parentTopic}"

PRIOR SYNTHESIZED FINDINGS (condensed — treat as established ground):
${synthesis || "(no synthesis on file)"}
${chatExcerpt ? `\nINTERROGATION EXCHANGES THAT MOTIVATED THIS FOLLOW-UP:\n${chatExcerpt}\n` : ""}${leadsBlock}
FOLLOW-UP DIRECTIVE FROM THE USER: "${directive}"`;
}

// -------------------------------------------------------------
// Directive Conditioner
// -------------------------------------------------------------
// The best runs this app has produced used a full research DIRECTIVE as the
// topic (primary question, epistemic categories, coverage, failure modes,
// numbered deliverables, research behaviour, success condition) followed by
// the user's own context. Plain one-line topics underperform with the same
// prompts. This step writes that directive for any input. The model writes
// ONLY the directive; the server appends the user's input verbatim, so
// nothing the user wrote can be shortened or lost.

// -------------------------------------------------------------
// Evidence Policy — the source rubric, separate from Fringe Mode
// -------------------------------------------------------------
// Fringe Mode is a verdict shape (Evidence Docket, open leads, provenance
// tags). Evidence policy is the source religion: which lanes are the spine
// and how a source earns credibility. They were welded together once and the
// institutional rubric outvoted the fringe costume. The only credibility axis
// anywhere in the pipeline is now CHAIN OF CUSTODY.
type EvidencePolicy = "mainstream-first" | "parity" | "fringe-first";

const normalizePolicy = (v: any, fringe: boolean): EvidencePolicy =>
  v === "mainstream-first" || v === "parity" || v === "fringe-first" ? v : fringe ? "fringe-first" : "mainstream-first";

const POLICY_LABEL: Record<EvidencePolicy, string> = {
  "mainstream-first": "MAINSTREAM-FIRST",
  parity: "PARITY",
  "fringe-first": "FRINGE-FIRST",
};

const CUSTODY_SCALE = `CHAIN-OF-CUSTODY SCORING (the only credibility axis, 0-10): 10 = you read the primary artifact itself (the filing, the scan, the original post, the dataset, the recording) at a resolvable location; 7-9 = a faithful copy or transcript whose original is identified and could be opened; 4-6 = a secondary account that names its primary source; 1-3 = a claim with no artifact behind it. Who published it is context you may note, never the score. Never label a source unreliable from memory; score what you actually traced. A traced artifact that CONTRADICTS a claim is a finding — record it as such.`;

function EVIDENCE_POLICY_BLOCK(policy: EvidencePolicy): string {
  const spine =
    policy === "fringe-first"
      ? `SPINE: archival and FOIA reading rooms, primary documents (patents, filings, court records, contracts, datasets), practitioner and researcher communities (forums, Discords, mailing lists, Substacks, podcasts, out-of-print books and scans), and original-era press are the backbone of this investigation. Mainstream summaries are context and are NOT required for a finding to stand. A finding supported by a traced community artifact outranks an untraced institutional summary. "The source is a forum" is never a defect; "the claim has no artifact" is.`
      : policy === "parity"
      ? `SPINE: institutional, press, archival, and practitioner sources carry EQUAL standing. A claim is strong when independent lanes converge on it and weak when one lane echoes itself — regardless of which lane. Do not discount a practitioner artifact for being a practitioner artifact, and do not promote a press summary for being press.`
      : `SPINE: institutional records and established press are the backbone; archival and practitioner material corroborates and extends them. Even here, credibility is chain of custody, not masthead: a press summary with no traceable primary scores below a scanned filing.`;
  return `EVIDENCE POLICY — ${POLICY_LABEL[policy]} (set by the user for this run).
The user owns the evidence policy. Apply it. Do not substitute your own judgment about which sources deserve weight.
${spine}
${CUSTODY_SCALE}
Stamp every report section that scores sources with "scored under ${POLICY_LABEL[policy]}".`;
}

function OPERATOR_DIRECTIVES_BLOCK(settings: any): string {
  const text = String(settings?.operatorDirectives || "").trim();
  if (!text) return "";
  return `OPERATOR DIRECTIVES (standing instructions from the user — they outrank every default rule that follows):
${text.slice(0, 4000)}

`;
}

interface ConditionerConfig {
  depth: "recon" | "standard" | "deep";
  fringe: boolean;
  redTeam: boolean;
  agentCount: number | "auto";
  policy: EvidencePolicy;
  operatorDirectives?: string;
}

const CONDITIONER_MAX_INPUT_WORDS = 12000;
const CONDITIONER_MIN_OUTPUT_WORDS = 300;
// A 2,000-word directive from a reasoning model can take several minutes;
// the generic JSON-call timeout (180 s) is too short for it.
const CONDITIONER_TIMEOUT_MS = 480000;

const CONDITIONER_SYSTEM = "You are the Directive Conditioner for a multi-agent research swarm. You turn a research request into a complete, machine-fitted research directive. You structure; you never research, never answer the question, and never restate the user's context back to them.";

const CONTEXT_FENCE_HEADER = "# AUTHORITATIVE CONTEXT (verbatim user input — treat as the project baseline; do not summarize it back)";

function assembleConditionedTopic(directive: string, rawTopic: string): string {
  return `${directive.trim()}\n\n---\n\n${CONTEXT_FENCE_HEADER}\n\n${rawTopic.trim()}`;
}

function buildConditionerPrompt(rawTopic: string, cfg: ConditionerConfig): string {
  const deliverableCount = cfg.depth === "recon" ? 3 : cfg.depth === "deep" ? 7 : 5;
  const wordTarget = cfg.depth === "recon" ? "900-1,400" : cfg.depth === "deep" ? "1,800-2,600" : "1,300-2,000";
  const agentFloors = cfg.depth === "recon" ? "800-1,200" : cfg.depth === "deep" ? "5,000-8,000" : "2,500-4,000";
  const synthFloor = cfg.depth === "recon" ? "1,500-2,500" : cfg.depth === "deep" ? "8,000-12,000" : "4,000-6,000";
  const epistemic = cfg.fringe
    ? `Use the case-file provenance tags this pipeline already enforces: [primary text], [community lore], [witness testimony], [documented anomaly], [official record], [verified]. Add [design choice] and [open question] if the request is about building or deciding something.`
    : `Define four to six labelled categories every claim must be tagged with. Default set: ESTABLISHED FACT (sourced, uncontested), REPORTED CLAIM (sourced, contested or single-source), INFERENCE (the agent's reasoning from facts), DESIGN CHOICE (a recommendation, not a finding), OPEN QUESTION (could not be settled this run). Rename or extend them to fit the request's domain.`;
  const verdictLine = cfg.fringe
    ? "This is a CASE FILE run: the synthesis opens with the state of the evidence and may legitimately conclude insufficient-to-conclude. The success condition must not demand a verdict."
    : "The synthesis opens with the direct answer to the primary question (the pick, the ranking, the verdict, the design). The success condition must say what that answer looks like.";

  return `Today's date is ${new Date().toDateString()}.

${OPERATOR_DIRECTIVES_BLOCK({ operatorDirectives: cfg.operatorDirectives })}${EVIDENCE_POLICY_BLOCK(cfg.policy)}

THE PIPELINE THIS DIRECTIVE WILL DRIVE (write for this machine, not for a chatbot):
- An orchestrator reads the directive, writes a need analysis, and sprouts ${cfg.agentCount === "auto" ? "3-9" : cfg.agentCount} specialist agents from it. Each agent runs SEQUENTIALLY and writes a ${agentFloors}-word report (depth: ${cfg.depth.toUpperCase()}).
- Every agent is web-grounded: the server runs SearXNG searches planned from the directive and the agent's assignment, fetches full page text from the top-ranked hits, and injects both into the agent's prompt; deep runs add a second search wave written from the first wave's results. Agents can quote and cite only what those searches return (plus native search on Gemini/Anthropic). They have no code execution, no file access, no databases.
- ${cfg.redTeam ? "A Red Team pass (VEX) cross-examines each report WITHOUT web access before synthesis." : "No Red Team pass this run."}
- A single synthesis model folds every report into one ${synthFloor}-word document with a fixed structure (executive summary, tracks and methodology, thematic insights, conflict/consensus/uncertainty, recommendations, conclusion, Source Ledger). ${verdictLine}
- Deliverables you specify must be things that structure can hold: tables, matrices, ranked lists, labelled sections, pipelines. Nothing interactive, nothing that needs tools the agents lack.

THE RESEARCH REQUEST (verbatim; the server will append this under an AUTHORITATIVE CONTEXT fence after your directive, so do NOT copy, summarize, or paraphrase it back):
<<<REQUEST
${rawTopic.trim()}
REQUEST>>>

YOUR JOB: write the DIRECTIVE that sits above that context. ${wordTarget} words of Markdown. Required sections, in this order, with these exact top-level headers:

# <TITLE> — RESEARCH DIRECTIVE
Two to six sentences of framing: what this run must produce, what it must NOT do (no broad histories, no restating context, no re-deriving what the request already establishes), and what the request already treats as settled.

# PRIMARY QUESTION
One question in a blockquote, then two to four sentences on the goal: what a useful answer is for, and what it is not for.

# CRITICAL DESIGN PRINCIPLE
The one constraint that most changes how agents should think about this request (for example: who the real decision-maker is, what must never be inherited, what the answer must be optimized for). If the request implies none, write one that sharpens the primary question. One short header line plus one paragraph.

# REQUIRED EPISTEMIC SEPARATION
${epistemic} One line per category: the label and the rule for using it.

# COVERAGE
The components, entities, functions, angles or candidates that MUST be addressed, as a bulleted list derived from the request. You may add obvious adjacent items; mark each added one "(added)". Agents are forbidden from skipping any listed item.
Named programs, people, organizations or documents in this list are SEEDS, not the territory: each is a trailhead the agent starts from, never a boundary it stops at. Phrase named items as "starting from X" and end the section with a mandatory bullet: "BEYOND THE SEEDS: every agent must report what the seeds LED TO that is not on this list — the successor entity, the co-author, the next contract, the name that appears in the same document — and treat an unlisted find as more valuable than a confirmed listed one." A run that only verifies the seeds has failed this section.

# KNOWN FAILURE MODES
At least ${cfg.depth === "recon" ? 3 : 5} traps specific to THIS topic (not generic research advice), each as a short bold name and one line on how an agent would detect it.

# REQUIRED DELIVERABLES
Exactly ${deliverableCount} numbered deliverables. For each: a short name, the shape (table with named columns / ranked list / matrix / labelled section / pipeline), and one line on what it must contain. These become the backbone of the synthesis; make them concrete enough that a missing one is obvious.

# RESEARCH BEHAVIOR
When agents should use live web search and when they should rely on the authoritative context; which kinds of sources are primary for this request; what "already known" means here so agents do not re-research it; and the rule that absence from a limited search is never evidence of absence.

# SUCCESS CONDITION
What a passing synthesis looks like, in the requester's own terms: three to six bullet points that could be checked against the final document.

RULES:
- THE EVIDENCE POLICY ABOVE GOVERNS EVERY SECTION YOU WRITE. The epistemic categories, failure modes, research behaviour and success condition must all score sources by chain of custody, never by who published them. One failure mode is FORBIDDEN: "the source is an anonymous forum / community site / blog" is NOT slippage and must not appear as a failure signal. Slippage is a claim with no artifact behind it. Provenance tags describe chain of custody, not permission to use: a [community lore] or [witness testimony] item with a recoverable original is evidence and may be a building block. Never write that any tag "never forms a building block" or similar.
- NO QUOTAS ON FINDINGS. Never set a numeric floor on what the research must find ("at least 10 individuals", "no fewer than 5 patents", "minimum 3 labs"). Quotas on evidence invite fabrication. Floors apply only to STRUCTURE: every deliverable present, every claim tagged, every gap registered as an open question. A deliverable's content line says what it must contain, never how many.
- Use only the epistemic tags you defined in REQUIRED EPISTEMIC SEPARATION; do not introduce new ones elsewhere in the directive.
- Write in English throughout.
- IMPROVE, DO NOT REPLACE. If the request already contains any of these sections or their equivalents (a stated primary question, deliverables, constraints, failure modes, a success condition), carry that material into the matching section VERBATIM and fill only what is missing. A request that is already a full directive should come out nearly unchanged plus the sections it lacked.
- Never research, never answer the question, never invent facts about the subject. Your knowledge of the domain may shape COVERAGE and KNOWN FAILURE MODES; it may not supply findings.
- Never copy or summarize the request text into the directive except where the IMPROVE rule requires carrying a section forward.
- Write in direct imperative prose. No preamble, no closing remarks, no commentary about this task. Output the directive only, starting with the title header.`;
}

async function conditionDirective(rawTopic: string, settings: any, cfg: ConditionerConfig): Promise<string | null> {
  const inputWords = rawTopic.trim().split(/\s+/).filter(Boolean).length;
  if (inputWords > CONDITIONER_MAX_INPUT_WORDS) {
    console.warn(`[Conditioner] skipped: input is ${inputWords} words (ceiling ${CONDITIONER_MAX_INPUT_WORDS}).`);
    return null;
  }
  const prompt = buildConditionerPrompt(rawTopic, cfg);
  let acc = "";
  try {
    await Promise.race([
      runUniversalStream("orchestrator", settings, prompt, CONDITIONER_SYSTEM, false, (t) => { acc += t; }),
      new Promise<never>((_, reject) => setTimeout(() => reject(new Error(`conditioner timed out after ${CONDITIONER_TIMEOUT_MS / 1000}s`)), CONDITIONER_TIMEOUT_MS)),
    ]);
  } catch (err: any) {
    console.warn(`[Conditioner] failed, using raw topic: ${err?.message || err}`);
    return null;
  }
  const directive = acc.trim();
  const outWords = directive.split(/\s+/).filter(Boolean).length;
  const hasPrimary = /^#\s*PRIMARY QUESTION/m.test(directive);
  if (outWords < CONDITIONER_MIN_OUTPUT_WORDS || !hasPrimary) {
    console.warn(`[Conditioner] output rejected (${outWords} words, primary-question header ${hasPrimary ? "present" : "missing"}); using raw topic.`);
    return null;
  }
  console.log(`[Conditioner] expanded ${inputWords} → ${outWords} directive words.`);
  return directive;
}

// -------------------------------------------------------------
// Fringe Mode — case-file investigation prompt blocks
// -------------------------------------------------------------
// The toggle flips the pipeline from verdict-oriented reporting to evidence
// accumulation: investigation-native personas, non-mainstream sourcing,
// provenance tagging, and an Evidence Docket synthesis that may legitimately
// conclude "insufficient to conclude".

const FRINGE_ORCHESTRATOR_HINT = `
FRINGE MODE — CASE FILE INVESTIGATION: This topic sits on the edges of mainstream coverage (fringe, esoteric, anomalous, heterodox, or frontier territory). Frame your mission analysis as OPENING A CASE FILE: what is actually claimed or reported, what evidence could exist, where that evidence would live, and what would move the case forward. Sprout investigation-native specialists fitted to this exact territory — examples of the species: an archives/FOIA hound for declassified and official records, an insider-practitioner fluent in the community's own literature, a historian of the subject's lineage, an anomaly cataloguer who inventories documented incidents, a lore cartographer mapping claims to their original sources, a frontier-lab watcher for research edges. Derive the team from the topic; do not force these examples. Do NOT field a mainstream-consensus gatekeeper persona ("the debunker") — in a case file, rigor lives in provenance, not dismissal.
ANCHOR REQUIREMENT (critical): each specialist's investigative assignment must NAME 2-4 concrete anchors to run down — specific facilities, programs, products, texts, traditions, researchers, or incidents — drawn from YOUR OWN knowledge of this territory's canon, including canonical examples the research request itself never mentions. An abstract mandate hides concrete trailheads; a fringe veteran already knows where they are. Abstract assignments ("analyze the pattern of...") with no named anchors are unacceptable.`;

const FRINGE_AGENT_RULES = `FRINGE INVESTIGATION RULES (mandatory — you are working a CASE FILE, not writing a verdict):
- CANON FIRST. Before anything else, lay out what the fringe/esoteric canon already holds on this territory FROM YOUR OWN KNOWLEDGE: the relevant traditions and their key terms, the texts and researchers, the recurring symbols and codename lineages, and the famous prior cases — then use live search to verify, date, and extend that map. A fringe veteran starts from the canon in their head, not from a blank search box. Name names; abstract pattern-talk without named anchors is a failed investigation.
- CONNECT ACROSS DOMAINS. The method of this territory is lineage-tracing: the same name, number, or symbol recurring across eras and institutions (a defense facility, an ancient tradition, a consumer product) IS the evidence trail. When you meet a loaded name, actively sweep the other domains it might appear in.
- Investigations accumulate. Collect and catalog evidence; do NOT close the case because early evidence is thin. A detective does not find the first clue and declare the crime never happened.
- Document the territory ON ITS OWN TERMS: map the claims, incidents, lineages, key figures, and internal logic faithfully. Do not pad the report with reflexive "however, experts dismiss this" hedging — skepticism belongs in provenance, not editorializing.
- PROVENANCE-TAG every major claim with one of: [primary text], [community lore], [witness testimony], [documented anomaly], [official record], [verified]. Let the tags do the epistemics.
- HUNT NON-MAINSTREAM SOURCES: archives and special collections (archive.org and national archives), declassified/FOIA reading rooms, court records, patent filings, out-of-print books and scans, preprints, niche journals, practitioner forums and communities, original-era newspapers. Mainstream summaries are a starting point, never the destination.
- End your report with an '## Open Leads' section listing 3-6 SPECIFIC, followable threads (a named archive to pull, a person to trace, a document to locate, a claim to cross-check) — never vague "more research needed" filler.`;

const FRINGE_SYNTHESIS_STRUCTURE = (topic: string) => `# ${topic}: Evidence Docket — Case File Synthesis

## 1. Case Status
- Open with exactly one status: EVIDENCE ACCUMULATING, THREADS CONVERGING, ACCOUNTS CONTESTED, or CASE COLD — followed by a short justification.
- "Insufficient to conclude" is a valid, respectable finding. Do NOT force a verdict the evidence cannot carry.

## 2. Case Overview
- What is claimed or reported, the scope of this investigation, and the specialist angles fielded.

## 3. Evidence Catalog
- The material gathered, organized by theme. PRESERVE the specialists' provenance tags ([primary text], [witness testimony], [official record], etc.) and citations.

## 4. Converging Threads
- Where independent lines of evidence point the same direction — the strongest patterns in the file.

## 5. Contradictions & Contested Ground
- Where accounts conflict, where evidence undercuts claims, and what remains genuinely unresolved.

## 6. Open Leads
- Consolidate and deduplicate the specialists' open leads into a prioritized list.
- Format each as: "LEAD: <the specific followable thread> — WHY: <what it could resolve>".

## 7. Case Notes
- Closing observations: the overall quality of the file, collection gaps, and what the next commission should target.`;

// -------------------------------------------------------------
// Sentinel Mode — delta sweep prompt blocks
// -------------------------------------------------------------
// A delta sweep (priorContext.delta) is a follow-up run whose sole mission is
// CHANGE DETECTION: agents hunt what moved since the prior findings instead
// of extending them, and the synthesis becomes a Delta Briefing. Manual
// trigger only — there is deliberately no scheduling/cron anywhere.

const DELTA_ORCHESTRATOR_DIRECTIVE = `
DELTA SWEEP — SENTINEL RE-CHECK: This run is a standing-watch sweep over a completed investigation, NOT a fresh survey. Sprout agents whose assignments are explicitly about CHANGE DETECTION since the prior run: new developments, new evidence, corrections, retractions, reversals, and shifts in the landscape the prior findings describe. Slice the prior synthesis into watch areas and assign each agent a slice — every assignment should read as "what has changed about X since the prior run", never "investigate X". Do NOT field agents to re-survey ground the prior synthesis already covers.`;

const DELTA_AGENT_RULES = `DELTA RULES (mandatory — this is a sentinel sweep, not a fresh investigation):
- Report ONLY what is NEW, CHANGED, or CORRECTED since the prior findings above. Do not restate stable prior material except as a one-line anchor for a change ("was X → now Y").
- For every area of your assignment where nothing has moved, say so explicitly: "No change detected — <area>". A verified absence of change is a finding; silence is not.
- Tag each finding as one of: NEW (previously unreported), CHANGED (prior finding needs updating), CORRECTED (prior finding was wrong), or CONFIRMED (prior finding independently re-verified).
- Date-stamp every change and cite the source establishing it happened after the prior run.`;

const DELTA_SYNTHESIS_STRUCTURE = (topic: string) => `# ${topic}: Delta Briefing

## 1. Sweep Summary
- One-paragraph verdict: how much has moved since the prior run — a lot, a little, or nothing — and the single most consequential change (or the absence of one).
- State the sweep window explicitly (prior run → today).

## 2. What's New
- Developments, evidence, and events that did not exist (or were unreported) at the time of the prior findings. Date-stamp and cite each. If nothing is new, say so plainly.

## 3. What Changed
- Prior findings that still hold in essence but need updating (numbers moved, timelines shifted, positions evolved). Pair each with its prior state: "was X → now Y".

## 4. What Was Overturned
- Prior findings the sweep shows to be wrong or no longer true. State plainly what should now be believed instead, and on what evidence. "Nothing overturned" is a meaningful result — say it if true.

## 5. What Stands Confirmed
- Prior findings the sweep re-verified or found no movement against. Consolidate the specialists' explicit "no change detected" entries here.

## 6. Watch Items
- What to monitor before the next sweep: pending decisions, expected releases, unresolved corrections, and weak signals that could mature into changes.
- Format each as: "WATCH: <the specific thing> — TRIGGER: <what movement would look like>".`;

// -------------------------------------------------------------
// Search Query Planner
// -------------------------------------------------------------
// Abstract mission seeds ("investigate the systemic pattern of...") produce
// abstract, useless search strings when queries are derived from the raw
// topic text. This pre-search step asks the orchestrator-role model to
// CONCRETIZE: name specific real-world entities (facilities, programs,
// products, people) that the mandate implies — including well-known examples
// the model knows of that the topic text never names. Falls back to naive
// topic/angle queries on any failure.
async function planSearchQueries(
  topic: string,
  angle: string,
  fringe: boolean,
  settings: any,
  policy: EvidencePolicy = "mainstream-first"
): Promise<string[]> {
  try {
    const schema = {
      type: Type.OBJECT,
      properties: {
        queries: {
          type: Type.ARRAY,
          description: "4-6 concrete web search queries",
          items: { type: Type.STRING },
        },
      },
      required: ["queries"],
    };
    const prompt = `RESEARCH TOPIC: "${topic.slice(0, 1500)}"
ASSIGNED INVESTIGATIVE ANGLE: "${angle.slice(0, 600)}"

Generate 4-6 concrete web search queries for this investigation. Rules:
- CONCRETIZE. Name specific entities — facilities, programs, products, people, organizations, documents — that this investigation should check. Include well-known real-world examples YOU know of that fit the topic's pattern, even when the topic text does not name them. An abstract mandate hides concrete anchors; your job is to surface them.
- Each query is a tight search-engine string (2-8 words), not a sentence or a question.
- Queries must not overlap heavily with each other.
- COVER DISTINCT ANGLES, not just topical restatements. Across the set, include at least one query hunting CRITIQUE / rebuttal / debate / counter-evidence on the central claim, and at least one probing INCENTIVE — who funds, profits from, or is harmed by the dominant position.${fringe ? `
- This is a FRINGE case-file investigation. THINK LIKE A VETERAN FRINGE RESEARCHER: draw on your knowledge of the esoteric/occult canon (Sumerian, Hermetic, alchemical, Thelemic, modern conspiracy-research literature), known symbol and codename lineages, classified-program insignia lore, and famous prior cases in this territory. Name the canonical anchors — specific facilities, program names, texts, researchers, incidents — that a fringe veteran would immediately check for this mandate.` : ""}${policy === "fringe-first" ? `
- EVIDENCE POLICY FRINGE-FIRST — the user owns this policy; apply it. The set MUST cover these lanes, one query each at minimum: (a) an archive / reading-room lane (site:archive.org, a FOIA reading room, a national archive, a court docket); (b) a primary-document lane (patent number, contract or grant identifier, filing, dataset); (c) a practitioner-community lane (a named forum, Discord, mailing list, Substack, podcast, or community wiki where the subject's people actually talk); (d) an original-era press or publication lane (the period's own newspapers, newsletters, zines, journals). Mainstream news summaries are NOT required.` : policy === "parity" ? `
- EVIDENCE POLICY PARITY — the user owns this policy; apply it. Cover BOTH institutional/press lanes AND archival + practitioner-community lanes (a named forum, Discord, mailing list, Substack or community wiki) with equal weight across the set.` : fringe ? `
- Include one query using site:archive.org and one aimed at declassified/FOIA material where relevant.` : ""}`;

    const result = await generateUnifiedJSON(
      "orchestrator",
      settings,
      prompt,
      "You are a research search-query planner. You turn abstract research mandates into concrete, high-recall web search queries, naming the specific real-world entities the mandate implies — including canonical examples the mandate's author left unstated.",
      schema
    );
    return (Array.isArray(result?.queries) ? result.queries : [])
      .filter((q: any) => typeof q === "string" && q.trim().length > 0)
      .map((q: string) => q.trim().slice(0, 120))
      .slice(0, 6);
  } catch (err: any) {
    console.warn(`[QueryPlan] Planning failed (${err.message}) — falling back to naive topic/angle queries.`);
    return [];
  }
}

async function generateUnifiedJSON(
  taskRole: TaskRole,
  settings: any,
  prompt: string,
  systemInstruction: string,
  responseSchema?: any
): Promise<any> {
  const { provider, model, apiKey, baseUrl } = getModelAndKey(taskRole, settings);

  if (provider === "gemini") {
    // httpOptions.timeout mirrors JSON_CALL_TIMEOUT_MS for the SDK path —
    // same hang risk as the raw-fetch providers.
    const client = new GoogleGenAI({ apiKey, httpOptions: { timeout: JSON_CALL_TIMEOUT_MS } });
    const response = await client.models.generateContent({
      model: model,
      contents: prompt,
      config: {
        systemInstruction,
        responseMimeType: "application/json",
        responseSchema,
        safetySettings: [
          { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" }
        ] as any
      }
    });

    const text = response.text;
    if (!text) throw new Error(`Empty response from Gemini orchestrator using model: ${model}`);
    return extractJSON(text);
  }

  let fullPrompt = `${systemInstruction}\n\nUser request:\n${prompt}`;
  fullPrompt += `\n\nCRITICAL: Respond ONLY with a valid, raw JSON representation matching the required schema. Do NOT wrap output in markdown enclosures like \`\`\`json. Your response must parse directly as a raw JSON string.`;
  // Gemini receives the schema natively; every other provider must see it in
  // the prompt or each model invents its own JSON shape.
  if (responseSchema) {
    fullPrompt += `\n\nThe JSON MUST conform exactly to this schema (property names and nesting are mandatory):\n${JSON.stringify(responseSchema)}`;
  }

  let responseText = "";

  if (provider === "anthropic") {
    const result = await callAnthropic(apiKey, {
      model,
      messages: [{ role: "user", content: fullPrompt }],
      max_tokens: 8000
    });
    responseText = result.content?.[0]?.text || "";
  } else {
    let targetUrl = "https://api.openai.com/v1/chat/completions";
    if (provider === "openrouter") targetUrl = "https://openrouter.ai/api/v1/chat/completions";
    else if (provider === "venice") targetUrl = "https://api.venice.ai/api/v1/chat/completions";
    else if (provider === "lmstudio") targetUrl = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
    else if (provider === "ollama") targetUrl = `${baseUrl.replace(/\/$/, "")}/v1/chat/completions`;

    const requestBody: any = {
      model,
      messages: [{ role: "user", content: fullPrompt }],
    };
    // LM Studio rejects response_format "json_object" (it only accepts
    // "json_schema"), and Ollama ignores it — the schema travels in the
    // prompt for those; hosted providers still get the strict-JSON hint.
    if (provider !== "lmstudio" && provider !== "ollama") {
      requestBody.response_format = { type: "json_object" };
    }
    const result = await callOpenAICompatible(targetUrl, apiKey, requestBody);
    responseText = result.choices?.[0]?.message?.content || "";
  }

  if (!responseText) throw new Error(`No content returned from ${provider} model: ${model}.`);
  return extractJSON(responseText);
}

// Appended to a report when the provider stopped at its output token limit,
// so a cut-off document is never mistaken for a finished one.
const TRUNCATION_MARKER = "\n\n> ⚠ OUTPUT TRUNCATED: the provider stopped at its output token limit. The report above is incomplete.";
const DEGENERATE_MARKER = "\n\n> ⚠ OUTPUT ENDED EARLY: the model began emitting blank filler after this point and the stream was cut at the last real text.";

// Some models (Gemini Flash via OpenRouter, observed 2026-10-08) finish a
// report and then emit whitespace tokens until the provider's output limit:
// a 12k-char report arrived as 1M chars. Once a whitespace run passes this
// length the stream is cut and the report marked.
const DEGENERATE_WS_RUN = 4000;
// Whitespace-only chunks beyond this run length are not forwarded at all.
const WS_FORWARD_LIMIT = 64;

// Collapse filler whitespace in a report before it enters any prompt or
// is persisted. Keeps markdown indentation (up to 8 spaces) and up to two
// blank lines.
function sanitizeReport(text: string): string {
  return String(text ?? "")
    .replace(/[^\S\n]{9,}/g, " ")
    .replace(/\n(?:[^\S\n]*\n){3,}/g, "\n\n\n")
    .trimEnd();
}

async function runUniversalStream(
  taskRole: TaskRole,
  settings: any,
  prompt: string,
  systemInstruction: string,
  hasSearch: boolean,
  onChunk: (text: string) => void,
  searchQueries?: string[],
  onGrounding?: (info: GroundingInfo) => void,
  // Opt-in two-wave iterative deepening. Only full agent investigations set
  // this; interrogation answers stay single-wave for responsiveness.
  deepenSearch?: boolean,
  // Real stage telemetry (searching / reading / reasoning / writing).
  onStage?: (s: StageInfo) => void,
  // Per-run evidence policy; controls the search mix in code.
  streamOpts?: { evidencePolicy?: EvidencePolicy }
): Promise<{ truncated: boolean; degenerate: boolean }> {
  let truncated = false;
  let degenerate = false;
  let stopRequested = false;
  let wsRun = 0;
  let wroteAny = false;
  // Every provider loop emits through this guard instead of onChunk directly.
  const emit = (text: string) => {
    if (stopRequested || !text) return;
    if (/^\s*$/.test(text)) {
      wsRun += text.length;
      if (wsRun >= DEGENERATE_WS_RUN) {
        degenerate = true;
        stopRequested = true;
        return;
      }
      if (wsRun > WS_FORWARD_LIMIT) return;
      onChunk(text);
      return;
    }
    if (!wroteAny) {
      wroteAny = true;
      onStage?.({ stage: "writing" });
    }
    const trailing = text.match(/\s*$/);
    wsRun = trailing ? trailing[0].length : 0;
    onChunk(text);
  };
  const { provider, model, apiKey, baseUrl } = getModelAndKey(taskRole, settings);

  // What the injected (SearXNG) pass put in the agent's hands, so a native
  // search tool can be leashed to the holes and audited afterwards.
  let injectedUrls: string[] = [];
  let injectedExtracted: string[] = [];
  let injectedQueries: string[] = [];
  const nativeHits: { url: string; title: string }[] = [];
  // Audit means drop. Two gates, both required for a native result to count:
  //  1. not already in the injected set (inject-membership), and
  //  2. ON TARGET — its title or URL names a query-plan target. SearXNG never
  //     touching a page does not make it a finding; a Wikipedia film page
  //     with the subject's name is adjacent noise, not an artifact.
  // If nothing survives, the gap pass came back empty and is reported that
  // way — never merged in and called deep.
  const auditNativePass = (label: string) => {
    if (!hasSearch) return;
    const have = new Set(injectedUrls.map(normUrl));
    const targets = new Set<string>();
    for (const q of injectedQueries) {
      for (const w of q.toLowerCase().replace(/site:\S+/g, " ").replace(/[^a-z0-9\s]/g, " ").split(/\s+/)) {
        if ((w.length >= 4 || /^\d{2,}$/.test(w)) && !QUERY_STOPWORDS.has(w)) targets.add(w);
      }
    }
    const onTarget = (h: { url: string; title: string }): boolean => {
      const hay = `${h.title} ${decodeURIComponent(h.url).replace(/[^a-zA-Z0-9]+/g, " ")}`.toLowerCase();
      let hits = 0;
      for (const t of targets) if (hay.includes(t)) { hits++; if (hits >= 2) return true; }
      return false;
    };
    const seen = new Set<string>();
    const fresh: string[] = [];
    let dupes = 0;
    let adjacent = 0;
    for (const h of nativeHits) {
      const n = normUrl(h.url);
      if (!n || seen.has(n)) continue;
      seen.add(n);
      if (have.has(n)) { dupes++; continue; }
      if (!onTarget(h)) { adjacent++; continue; }
      fresh.push(h.url);
    }
    if (nativeHits.length === 0) {
      onGrounding?.({ mode: "native", detail: `${label}: gap pass ran no searches` });
    } else if (fresh.length === 0) {
      onGrounding?.({ mode: "native", detail: `${label}: gap pass came back EMPTY — ${dupes} already in hand and ${adjacent} off-target result(s) dropped; no new grounding from the native tool` });
    } else {
      onGrounding?.({ mode: "native", detail: `${label}: gap pass found ${fresh.length} on-target artifact(s) (${dupes} duplicate(s), ${adjacent} off-target dropped) — ${fresh.slice(0, 4).join(" | ")}` });
    }
  };

  // Local SearXNG grounding is the workhorse for EVERY provider — native
  // search tools (Gemini/Anthropic/plugins) ride on top as a bonus, but the
  // injected block guarantees each agent real, ranked, full-text sources.
  // If gathering fails the model is told to caveat staleness instead of
  // silently roleplaying a web search it never ran.
  if (hasSearch) {
    try {
      const queries = searchQueries && searchQueries.length > 0 ? searchQueries : [prompt.slice(0, 200)];
      const refiner = deepenSearch
        ? (digest: string, alreadyRun: string[]) => refineQueriesFromResults(settings, digest, alreadyRun)
        : undefined;
      const newsLane = streamOpts?.evidencePolicy !== "fringe-first";
      console.log(`[Grounding] evidence policy ${streamOpts?.evidencePolicy || "mainstream-first"} — news lane ${newsLane ? "ON" : "OFF"}`);
      const { block, hitCount, engine, pages, waves, urls, extractedUrls, queries: ranQueries } = await gatherLiveContext(queries, refiner, onStage, newsLane);
      injectedUrls = urls;
      injectedExtracted = extractedUrls;
      injectedQueries = ranQueries;
      if (hitCount > 0) {
        const noOwnSearch = NATIVE_SEARCH_PROVIDERS.has(provider)
          ? "- Your provider may weave additional live web results into this run; those plus the LIVE WEB SEARCH RESULTS block above are your ONLY live sources."
          : "- You have NO search capability of your own — no Google, no databases, no registries, no archives. The searches listed in the LIVE WEB SEARCH RESULTS block are the ONLY searches that were run, by the research system, on your behalf.";
        prompt = `${block}\n\n---\n\n${prompt}\n\nGROUNDING RULES (mandatory):
${noOwnSearch}
- Never describe a search you did not actually run. The LIVE WEB SEARCH RESULTS block lists the searches the research system ran for you; if you have a web search tool of your own, searches you run with it are yours to report, by their exact query. A methodology section describes exactly those searches and what they returned — nothing else. Do NOT invent a null ("no coverage", "no results") for a search that was never run.
- Ground every time-sensitive claim in the numbered results and cite them inline with their URLs. Where the results do not cover a point, write "the provided live results do not cover this" — do not fill the gap with memorized training data presented as current.
- Result dates may differ from your stated date by up to a day due to timezones. That is normal publishing skew, not an anomaly — do not build theories on it.`;
        onGrounding?.({ mode: "injected", detail: `${hitCount} live search results + ${pages} full-page extracts injected via ${engine} across ${waves} search wave${waves === 1 ? "" : "s"} — seed queries: ${queries.map((q) => `"${q.slice(0, 60)}"`).join(" | ")}` });
      } else {
        prompt = `${prompt}\n\nWARNING — LIVE SEARCH UNAVAILABLE (a tooling failure, NOT a reflection on the topic): no live web data could be retrieved for this run. You MUST state this plainly at the top of your report. Your training data may predate recent events, so NEVER declare that something "does not exist" or that there is "no evidence" of it based on memory alone — recent products, events, and coverage may simply postdate your knowledge. Write "live verification was unavailable this run" instead, flag memory-based findings as potentially outdated, and date-stamp any claim that could have changed.`;
        onGrounding?.({ mode: "none", detail: `Live search unavailable (SearXNG at ${SEARXNG_BASE_URL}${BRAVE_SEARCH_API_KEY ? " + Brave" : ""}${TAVILY_API_KEY ? " + Tavily" : ""} returned no results) — falling back to model knowledge` });
      }
    } catch (err: any) {
      console.warn(`[Grounding] Live context gathering failed: ${err.message}`);
      prompt = `${prompt}\n\nWARNING: No live web data could be retrieved for this run. You must explicitly flag that your findings come from model training data and may be outdated, and date-stamp any claim that could have changed.`;
      onGrounding?.({ mode: "none", detail: `Live search failed (${err.message}) — falling back to model knowledge` });
    }
  }

  // Prompt is final from here: the model is thinking until its first token.
  onStage?.({ stage: "reasoning" });

  // Providers with genuinely agentic native search also run their own real
  // queries on top of the injected block — hold them to the same honesty bar.
  if (hasSearch && AGENTIC_SEARCH_PROVIDERS.has(provider)) {
    if (injectedUrls.length > 0) {
      // Leash, not kill: the native tool hunts the holes, never the homework.
      const extractedSet = new Set(injectedExtracted.map(normUrl));
      const notOpened = injectedUrls.filter((u) => !extractedSet.has(normUrl(u)));
      prompt = `${prompt}\n\nNATIVE SEARCH GAP ORDER (mandatory — your web search tool is on a leash):
The research system already ran ${injectedQueries.length} queries (listed in the LIVE WEB SEARCH RESULTS block) and holds ${injectedUrls.length} result URLs; ${injectedExtracted.length} of them were opened and their full text is in FULL SOURCE EXTRACTS. Everything in that block is ALREADY IN HAND. Deep means the second pass hunts the hole, not a paid encore of the first.
Use your own search tool ONLY for the holes:
  (a) a result in the block that was NOT opened — the pages nobody read. Those URLs are:${notOpened.length ? `\n${notOpened.slice(0, 14).map((u) => `     - ${u}`).join("\n")}` : " (every listed result was opened)"}
  (b) a name, document, identifier or event that the results surfaced but no page resolves — the thing the second wave dug up and abandoned;
  (c) the artifact classes the directive asks for that the block lacks: the original-era newspaper, the methods appendix, the filing or contract itself, the dataset.
Rules: never re-run or paraphrase a listed query; never re-open a URL that was already extracted; a URL already in the block is NOT a finding of yours — cite the block entry instead. If your searches return only URLs already in the block, write exactly "Gap pass came back empty." and cite nothing from it as new grounding. Every native result you DO use is cited by its exact query and URL and marked [native pass]. Never describe a search you did not actually execute; if a real query returned nothing, quote that exact query. Result dates may differ from your stated date by up to a day due to timezones; that is normal, not an anomaly.`;
    } else {
      prompt = `${prompt}\n\nSEARCH HONESTY (mandatory): Run real queries with your web search tool and cite the actual results. Never describe a search you did not actually execute this run, and never report a null for a query you did not run — if a real query returned nothing, quote that exact query. Result dates may differ from your stated date by up to a day due to timezones; that is normal, not an anomaly.`;
    }
  }

  if (provider === "gemini") {
    // Native grounding is reported AFTER the stream, from an audit of what the
    // tool actually returned against the injected set (see auditNativePass).
    const client = new GoogleGenAI({ apiKey });
    const responseStream = await client.models.generateContentStream({
      model: model,
      contents: prompt,
      config: {
        systemInstruction,
        ...(hasSearch ? { tools: [{ googleSearch: {} }] } : {}),
        safetySettings: [
          { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
          { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" }
        ] as any
      }
    });

    for await (const chunk of responseStream) {
      if (chunk.text) {
        emit(chunk.text);
      }
      const gChunks: any[] = (chunk.candidates?.[0] as any)?.groundingMetadata?.groundingChunks || [];
      for (const gc of gChunks) if (gc?.web?.uri) nativeHits.push({ url: String(gc.web.uri), title: String(gc.web.title || "") });
      const finish = chunk.candidates?.[0]?.finishReason as string | undefined;
      if (finish === "MAX_TOKENS") truncated = true;
      else if (finish === "SAFETY" || finish === "RECITATION" || finish === "PROHIBITED_CONTENT") {
        throw new Error(`Gemini stopped the stream: finishReason=${finish}.`);
      }
      if (stopRequested) break;
    }
    auditNativePass("Gemini Google Search");
    return { truncated: truncated && !degenerate, degenerate };
  }

  if (provider === "anthropic") {
    // Native grounding is reported AFTER the stream, from an audit of what the
    // tool actually returned against the injected set (see auditNativePass).
    // Claude 5.x thinks by default (Opus can't turn it off) and thinking
    // tokens plus the web-search tool loop all count against max_tokens.
    // 16k left Haiku 5.5 forty visible words per report (2026-10-08). Give
    // streaming requests room: 128k is the output cap on these models.
    const anthropicMaxTokens = taskRole === "synthesis" ? 128000 : taskRole === "agent" ? 64000 : 16000;
    // Opus/Sonnet 4.6+ take the dynamic-filtering web search tool; Haiku and
    // older models keep the basic variant.
    const webSearchType = /claude-(opus|sonnet)-(4-[6-9]|5)/.test(model) ? "web_search_20260209" : "web_search_20250305";
    const response = await fetch("https://api.anthropic.com/v1/messages", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": apiKey,
        "anthropic-version": "2023-06-01"
      },
      body: JSON.stringify({
        model,
        messages: [{ role: "user", content: `${systemInstruction}\n\n${prompt}` }],
        max_tokens: anthropicMaxTokens,
        ...(hasSearch ? { tools: [{ type: webSearchType, name: "web_search", max_uses: 8 }] } : {}),
        stream: true
      })
    });

    if (!response.ok) {
      const errText = await response.text();
      throw new Error(`Anthropic streaming status ${response.status}: ${errText}`);
    }

    const reader = response.body as any;
    if (!reader) throw new Error("Anthropic response body is empty.");

    // Stream chunks are Uint8Array — String(chunk) would render comma-joined
    // byte values, so decode them as UTF-8 text.
    const sseDecoder = new TextDecoder();
    let buffer = "";
    for await (const chunk of reader) {
      buffer += typeof chunk === "string" ? chunk : sseDecoder.decode(chunk, { stream: true });
      const lines = buffer.split("\n");
      buffer = lines.pop() || "";

      for (const line of lines) {
        const cleanLine = line.trim();
        if (!cleanLine) continue;

        if (cleanLine.startsWith("data: ")) {
          try {
            const parsed = JSON.parse(cleanLine.substring(6));
            if (parsed.type === "content_block_delta" && parsed.delta?.text) {
              emit(parsed.delta.text);
            } else if (parsed.type === "message_delta" && parsed.delta?.stop_reason === "max_tokens") {
              truncated = true;
            } else if (parsed.type === "content_block_start" && parsed.content_block?.type === "web_search_tool_result") {
              const results = Array.isArray(parsed.content_block.content) ? parsed.content_block.content : [];
              for (const r of results) if (r?.url) nativeHits.push({ url: String(r.url), title: String(r.title || "") });
            } else if (parsed.type === "error") {
              throw new Error(`Anthropic stream error: ${parsed.error?.message || JSON.stringify(parsed.error || parsed)}`);
            }
          } catch (e: any) {
            if (e instanceof SyntaxError) continue; // partial chunk
            throw e;
          }
        }
        if (stopRequested) break;
      }
      if (stopRequested) break;
    }
    auditNativePass("Anthropic web_search");
    return { truncated: truncated && !degenerate, degenerate };
  }

  // OpenAI-compatible providers
  let targetUrl = "https://api.openai.com/v1/chat/completions";
  if (provider === "openrouter") targetUrl = "https://openrouter.ai/api/v1/chat/completions";
  else if (provider === "venice") targetUrl = "https://api.venice.ai/api/v1/chat/completions";
  else if (provider === "lmstudio") targetUrl = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
  else if (provider === "ollama") targetUrl = `${baseUrl.replace(/\/$/, "")}/v1/chat/completions`;

  // OpenRouter and Venice run web search server-side when asked; the results
  // are woven into the completion by the provider itself.
  let searchExtras: Record<string, any> = {};
  if (hasSearch && provider === "openrouter") {
    searchExtras = { plugins: [{ id: "web" }] };
    onGrounding?.({ mode: "native", detail: "OpenRouter web plugin active" });
  } else if (hasSearch && provider === "venice") {
    searchExtras = { venice_parameters: { enable_web_search: "on", enable_web_citations: true } };
    onGrounding?.({ mode: "native", detail: "Venice web search active" });
  }

  const response = await fetch(targetUrl, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      ...(apiKey ? { "Authorization": `Bearer ${apiKey}` } : {})
    },
    body: JSON.stringify({
      model,
      messages: [
        { role: "system", content: systemInstruction },
        { role: "user", content: prompt }
      ],
      ...searchExtras,
      stream: true
    })
  });

  if (!response.ok) {
    const errText = await response.text();
    throw new Error(`${provider.toUpperCase()} streaming status ${response.status}: ${errText}`);
  }

  const reader = response.body as any;
  if (!reader) throw new Error(`${provider.toUpperCase()} response body is empty.`);

  // Stream chunks are Uint8Array — String(chunk) would render comma-joined
  // byte values, so decode them as UTF-8 text.
  const sseDecoder = new TextDecoder();
  let buffer = "";
  for await (const chunk of reader) {
    buffer += typeof chunk === "string" ? chunk : sseDecoder.decode(chunk, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() || "";

    for (const line of lines) {
      const cleanLine = line.trim();
      if (!cleanLine) continue;
      if (cleanLine === "data: [DONE]") continue;

      if (cleanLine.startsWith("data: ")) {
        try {
          const parsed = JSON.parse(cleanLine.substring(6));
          if (parsed.error) {
            throw new Error(`${provider.toUpperCase()} stream error: ${parsed.error.message || JSON.stringify(parsed.error)}`);
          }
          const text = parsed.choices?.[0]?.delta?.content || "";
          if (text) {
            emit(text);
          }
          if (parsed.choices?.[0]?.finish_reason === "length") truncated = true;
        } catch (e: any) {
          if (e instanceof SyntaxError) continue; // partial chunk
          throw e;
        }
      }
      if (stopRequested) break;
    }
    if (stopRequested) break;
  }
  return { truncated: truncated && !degenerate, degenerate };
}

async function startServer() {
  const app = express();
  // 3369 stays clear of common dev/Docker ports (3000 = Open WebUI, etc.);
  // override with PORT in .env if needed.
  const BASE_PORT = Number(process.env.PORT) || 3369;

  // Parse JSON payloads (support larger payload size for multiple research reports)
  app.use(express.json({ limit: "15mb" }));
  // Generated agent portraits; immutable per persona key, so cache hard.
  app.use("/portraits", express.static(PORTRAITS_DIR, { maxAge: "30d", immutable: true }));

  // API Health Endpoint — env_keys reports which providers have server-side
  // .env keys (booleans only) so the Settings UI can enable fetching.
  app.get("/api/health", (req, res) => {
    res.json({
      status: "ok",
      api_key_set: !!apiKey,
      env_keys: {
        gemini: !!envKeyFor("gemini"),
        openrouter: !!envKeyFor("openrouter"),
        openai: !!envKeyFor("openai"),
        anthropic: !!envKeyFor("anthropic"),
        venice: !!envKeyFor("venice"),
      },
    });
  });

  // Fetch Models Endpoint for testing connection and loading available models
  app.post("/api/settings/fetch-models", async (req, res) => {
    try {
      const { provider, baseUrl } = req.body;
      if (!provider) {
        return res.status(400).json({ error: "Provider is required." });
      }
      const provKey = req.body.apiKey || envKeyFor(provider);

      let models: string[] = [];

      if (provider === "gemini") {
        try {
          const client = new GoogleGenAI({ apiKey: provKey || process.env.GEMINI_API_KEY || "" });
          // models.list() returns a Pager, which is only ASYNC-iterable — a
          // plain for..of throws and used to silently trigger the fallback.
          const pager = await client.models.list({ config: { pageSize: 100 } });
          for await (const m of pager as any) {
            if (m.name) {
              models.push(m.name.replace("models/", ""));
            }
          }
          models = models.filter((name: string) => name.includes("gemini") || name.includes("learnlm"));
        } catch (err: any) {
          console.warn(`[Models] Gemini model listing failed (${err?.message || err}) — serving fallback list.`);
          models = ["gemini-3.5-flash", "gemini-3.1-pro-preview", "gemini-3.1-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro"];
        }
      } else if (provider === "openai") {
        const url = "https://api.openai.com/v1/models";
        const response = await fetch(url, {
          headers: { "Authorization": `Bearer ${provKey}` }
        });
        if (!response.ok) {
          throw new Error(`OpenAI API responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.data.map((m: any) => m.id).filter((id: string) => id.includes("gpt") || id.includes("o1") || id.includes("o3"));
      } else if (provider === "openrouter") {
        const url = "https://openrouter.ai/api/v1/models";
        const response = await fetch(url);
        if (!response.ok) {
          throw new Error(`OpenRouter API responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.data.map((m: any) => m.id);
      } else if (provider === "anthropic") {
        const response = await fetch("https://api.anthropic.com/v1/models?limit=100", {
          headers: { "x-api-key": provKey, "anthropic-version": "2023-06-01" }
        });
        if (!response.ok) {
          throw new Error(`Anthropic API responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.data.map((m: any) => m.id);
      } else if (provider === "venice") {
        const url = "https://api.venice.ai/api/v1/models";
        const response = await fetch(url, {
          headers: { "Authorization": `Bearer ${provKey}` }
        });
        if (!response.ok) {
          throw new Error(`Venice API responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.data.map((m: any) => m.id);
      } else if (provider === "lmstudio") {
        const base = baseUrl.replace(/\/$/, "");
        let response;
        try {
          response = await fetch(`${base}/models`);
        } catch (e) {
          response = await fetch(`${base}/v1/models`);
        }
        if (!response.ok) {
          throw new Error(`LM Studio responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.data.map((m: any) => m.id);
      } else if (provider === "ollama") {
        const base = baseUrl.replace(/\/$/, "");
        const response = await fetch(`${base}/api/tags`);
        if (!response.ok) {
          throw new Error(`Ollama responded with status ${response.status}`);
        }
        const data = await response.json() as any;
        models = data.models.map((m: any) => m.name);
      }

      // Filter empty/nulls and sort alphabetically
      models = models.filter((m: any) => !!m).sort((a: string, b: string) => a.localeCompare(b));

      res.json({ models });
    } catch (error: any) {
      console.error(`Error fetching models for ${req.body.provider}:`, error);
      res.status(500).json({ error: error.message || "Failed to fetch models from provider." });
    }
  });

  // 1. Swarm Assembly Endpoint - Breaks a topic down into 5-7 parallel agents
  app.post("/api/research/initiate", async (req, res) => {
    try {
      const { topic, settings, config, priorContext } = req.body;
      if (!topic || typeof topic !== "string" || topic.trim().length === 0) {
        return res.status(400).json({ error: "A valid research topic is required." });
      }
      const priorBlock = formatPriorContextBlock(priorContext);

      // "auto" (or anything non-numeric) lets the orchestrator size the swarm
      // from its analysis of the research need; a number pins the count.
      const rawCount = config ? config.agentCount : "auto";
      const pinnedCount = typeof rawCount === "number" ? Math.max(3, Math.min(9, Math.round(rawCount))) : null;
      const depth = config && config.depth ? config.depth : "standard";
      const fringe = !!(config && config.fringeMode);
      const roster = !!(config && config.rosterMode);
      // Saved Agent Library entries sent by the client only in Roster Mode.
      const savedAgents: any[] = roster && Array.isArray(req.body.savedAgents)
        ? req.body.savedAgents.filter((a: any) => a && a.id && a.name && a.role)
        : [];
      const delta = !!(priorContext && priorContext.delta);

      let depthHint = "";
      if (depth === "recon") {
        depthHint = "\nDEPTH MODE — RECON: Keep each agent's assignment tightly scoped and narrowly focused for rapid tactical coverage. Avoid sprawling, open-ended mandates.";
      } else if (depth === "deep") {
        depthHint = "\nDEPTH MODE — DEEP: Make each agent's assignment maximally ambitious and far-reaching, probing edge cases, second-order effects, and deep technical frontiers.";
      }

      // Roster Mode needs its library before anything is spent on conditioning.
      if (roster && savedAgents.length < 2) {
        return res.status(400).json({ error: "Roster Mode needs at least 2 agents in your Agent Library. Save specialists from a swarm (bookmark icon on their card) or forge them in the Agent Library, then relaunch." });
      }

      // Directive Conditioner: fresh runs only (follow-ups and delta sweeps
      // already carry a directive and prior context). Default ON; the
      // client sends conditionDirective: false to bypass.
      const rawTopic = String(topic);
      // Evidence policy: separate from Fringe Mode; defaults by it when unset.
      const policy = normalizePolicy(config?.evidencePolicy, fringe);
      const wantsConditioning = !priorBlock && !(config && config.conditionDirective === false);
      let effectiveTopic = rawTopic;
      let conditioned: string | null = null;
      if (wantsConditioning) {
        const directive = await conditionDirective(rawTopic, settings, {
          depth,
          fringe,
          redTeam: !!(config && config.redTeam),
          agentCount: pinnedCount ?? "auto",
          policy,
          operatorDirectives: settings?.operatorDirectives,
        });
        if (directive) {
          conditioned = assembleConditionedTopic(directive, rawTopic);
          effectiveTopic = conditioned;
        }
      }

      console.log(`Assembling ${delta ? "DELTA-SWEEP " : priorBlock ? "FOLLOW-UP " : ""}${fringe ? "FRINGE " : ""}${roster ? "ROSTER " : ""}research swarm for topic: "${rawTopic.slice(0, 120)}"${conditioned ? " [conditioned]" : ""} (${pinnedCount ?? "auto"} agents, ${depth} depth)`);

      // ROSTER MODE: draft exclusively from the user's saved Agent Library.
      // A fully separate early-return path — the default on-the-fly generation
      // below is deliberately untouched.
      if (roster) {
        const maxPick = Math.min(9, savedAgents.length);
        const rosterListing = savedAgents
          .map((a: any) => `- id "${a.id}" — ${a.name}, ${a.role}. Standing specialty: ${String(a.investigativeAngle || "").slice(0, 400)}`)
          .join("\n");

        const today2 = new Date().toDateString();
        const followUpFraming2 = priorBlock
          ? `\n\n${priorBlock}\n\nFOLLOW-UP RULES: The prior findings above are ESTABLISHED GROUND. Draft the members whose specialties best target what is missing or unresolved.${delta ? `\n${DELTA_ORCHESTRATOR_DIRECTIVE}` : ""}`
          : "";

        const rosterPrompt = `Today's date is ${today2}.

RESEARCH REQUEST: "${effectiveTopic}"${followUpFraming2}

${OPERATOR_DIRECTIVES_BLOCK(settings)}${EVIDENCE_POLICY_BLOCK(policy)}
Draft members whose standing specialties can actually work the lanes this policy names.

ROSTER MODE: You must draft the team EXCLUSIVELY from the user's saved Agent Library below. You may NOT invent new agents, rename anyone, or alter identities — selection and per-mission tasking only.

AGENT LIBRARY:
${rosterListing}

Work in two phases.

PHASE 1 — ANALYZE THE RESEARCH NEED:
Diagnose what this request actually requires and which expertise it demands. Write a concise mission analysis of 60-140 words (the "needAnalysis" field). Note where the library covers the need well and where coverage is thin.

PHASE 2 — DRAFT FROM THE LIBRARY:
Select ${pinnedCount ? `exactly ${Math.min(pinnedCount, maxPick)}` : `between 2 and ${maxPick} (your call — exactly as many as the need demands, no padding)`} agents from the library, by their exact ids.
- Choose ONLY members whose standing specialty genuinely serves this mission — do not pad the team with poor fits.
- For each selected agent, write a "missionAngle": a specific investigative assignment for THIS topic that builds directly on their standing specialty, stating what they must find out and which kinds of sources or evidence to chase.${depthHint}${fringe ? `\n${FRINGE_ORCHESTRATOR_HINT}` : ""}`;

        const rosterSystemInstruction = "You are an elite Research Swarm Orchestrator operating in ROSTER MODE. You draft investigation teams exclusively from the user's saved agent library — never inventing, renaming, or reshaping personas — and tailor each drafted member's mission assignment to the research need.";

        const rosterSchema = {
          type: Type.OBJECT,
          properties: {
            needAnalysis: {
              type: Type.STRING,
              description: "Concise diagnosis (60-140 words) of what this research need requires and how the library covers it."
            },
            selections: {
              type: Type.ARRAY,
              description: "The drafted team, selected from the library by exact id.",
              items: {
                type: Type.OBJECT,
                properties: {
                  id: { type: Type.STRING, description: "EXACT id of a library agent (copy verbatim from the AGENT LIBRARY list)" },
                  missionAngle: { type: Type.STRING, description: "Topic-specific investigative assignment building on this agent's standing specialty" },
                },
                required: ["id", "missionAngle"],
              },
            },
          },
          required: ["needAnalysis", "selections"],
        };

        const byId = new Map(savedAgents.map((a: any) => [String(a.id), a]));
        let drafted: any[] = [];
        let rosterNeedAnalysis = "";
        let rosterLastError: any = null;

        for (let attempt = 1; attempt <= 2; attempt++) {
          const attemptPrompt = attempt === 1
            ? rosterPrompt
            : `${rosterPrompt}\n\nIMPORTANT: Your previous response was unusable. Return ONLY a single raw JSON object with a "needAnalysis" string and a "selections" array of FLAT objects, each having exactly these string keys: id (copied VERBATIM from the AGENT LIBRARY list), missionAngle.`;

          let result: any = null;
          try {
            result = await generateUnifiedJSON("orchestrator", settings, attemptPrompt, rosterSystemInstruction, rosterSchema);
          } catch (err: any) {
            rosterLastError = err;
            console.warn(`[Initiate/Roster] Attempt ${attempt}: unparseable — ${err.message}`);
            continue;
          }

          let selections: any[] = Array.isArray(result?.selections) ? result.selections : Array.isArray(result) ? result : [];
          // Hallucinated or malformed picks are discarded, never repaired into
          // new personas — identity lock is the point of Roster Mode.
          const seenIds = new Set<string>();
          selections = selections.filter((s: any) => {
            if (!s || typeof s.id !== "string" || !byId.has(s.id) || seenIds.has(s.id)) return false;
            seenIds.add(s.id);
            return true;
          });

          if (selections.length >= 2) {
            drafted = selections;
            rosterNeedAnalysis = typeof result?.needAnalysis === "string" ? result.needAnalysis.trim() : "";
            break;
          }
          console.warn(`[Initiate/Roster] Attempt ${attempt}: only ${selections.length} valid library picks. Raw: ${JSON.stringify(result).slice(0, 600)}`);
        }

        if (drafted.length < 2) {
          throw new Error(`Roster selection failed — the orchestrator could not draft a valid team from your Agent Library${rosterLastError ? ` (${rosterLastError.message?.slice(0, 200)})` : ""}. Try a different orchestrator model, or check that library specialties are described clearly.`);
        }

        const rosterAgents = drafted.slice(0, maxPick).map((s: any) => {
          const src = byId.get(s.id);
          return {
            id: src.id,
            name: src.name,
            role: src.role,
            investigativeAngle: (typeof s.missionAngle === "string" && s.missionAngle.trim())
              ? s.missionAngle.trim()
              : src.investigativeAngle,
            colorTheme: src.colorTheme || "cyan",
          };
        });

        return res.json({ agents: rosterAgents, needAnalysis: rosterNeedAnalysis, rawTopic, ...(conditioned ? { directive: conditioned } : {}) });
      }

      const today = new Date().toDateString();
      // Delta sweeps sharpen the follow-up framing further: the team exists
      // to hunt CHANGES since the prior run, not to extend it.
      const followUpFraming = priorBlock
        ? `\n\n${priorBlock}\n\nFOLLOW-UP RULES: The prior findings above are ESTABLISHED GROUND. Diagnose the follow-up need itself — the gaps, open questions, and weak spots the directive targets. Sprout agents aimed squarely at what is missing or unresolved; do NOT field agents to re-cover ground the prior run already settled (unless the directive is to verify or challenge it).${delta ? `\n${DELTA_ORCHESTRATOR_DIRECTIVE}` : ""}`
        : "";
      const prompt = `Today's date is ${today}.

RESEARCH REQUEST: "${effectiveTopic}"${followUpFraming}

${OPERATOR_DIRECTIVES_BLOCK(settings)}${EVIDENCE_POLICY_BLOCK(policy)}
Sprout specialists who can actually work the lanes this policy names.

Work in two phases.

PHASE 1 — ANALYZE THE RESEARCH NEED (this drives everything else):
Before thinking about any team, diagnose what this request actually requires:
- Separate the PRIMARY QUESTION from supporting CONTEXT. The primary question is what the user wants ANSWERED (the pick, the ranking, the verdict, the explanation). Context — hardware specs, budgets, locations, deadlines, exclusions — merely constrains and calibrates that answer. State both explicitly in your analysis.
- What kind of question is it (technical evaluation, market scan, product comparison, historical inquiry, scientific review, investigation of a person/organization/event, local or situational lookup, how-to, etc.)?
- What must a genuinely useful answer contain, and what evidence would settle it?
- Which domains of expertise are truly required — and, just as important, which classic research angles are IRRELEVANT to this particular need?
Write this diagnosis up as a concise mission analysis of 60-140 words (the "needAnalysis" field).

PHASE 2 — SPROUT THE TEAM FROM THE ANALYSIS:
Design ${pinnedCount ? `exactly ${pinnedCount}` : "between 3 and 9 (your call — exactly as many as the need demands, no padding)"} specialist research agents, each derived directly from a requirement identified in Phase 1.
- Every agent must map to a concrete requirement of THIS request. Do NOT apply a stock template of perspectives (technical / socioeconomic / historical / ethical / futuristic) unless your analysis shows that angle is genuinely needed here.
- KEEP THE SWARM POINTED AT THE PRIMARY QUESTION. Context details (the user's hardware, budget, location, exclusions) are lenses every agent applies to their findings — NOT research subjects. Never spend the majority of the team investigating the user's own constraints: for a "best X for my setup" request, field agents that FIND and RANK the X's, with at most one agent validating fit against the setup — and only if the analysis shows fit is genuinely uncertain or decisive.
- If the need is narrow, prefer a small team of tightly targeted agents over generic filler roles.
- Give each agent a unique creative persona name, a specialty title a real expert in this exact problem space would hold, a specific investigative assignment stating what they must find out and which kinds of sources or evidence to chase, and a theme color.${depthHint}${fringe ? `\n${FRINGE_ORCHESTRATOR_HINT}` : ""}`;

      const systemInstruction = fringe
        ? "You are an elite Research Swarm Orchestrator running in FRINGE case-file mode. You diagnose what an edge-territory investigation truly needs — treating the subject as a case to be worked, not a claim to be adjudicated — then assemble a bespoke team of investigation-native specialist personas shaped entirely by that diagnosis."
        : "You are an elite Research Swarm Orchestrator. You first diagnose what a research request truly needs, then assemble a bespoke team of specialist digital persona agents shaped entirely by that diagnosis — never by a fixed template of roles.";

      const responseSchema = {
        type: Type.OBJECT,
        description: "An object containing the mission analysis and the list of specialized research agents derived from it.",
        properties: {
          needAnalysis: {
            type: Type.STRING,
            description: "Concise diagnosis (60-140 words) of what this research need actually requires and which expertise it demands."
          },
          agents: {
            type: Type.ARRAY,
            description: "List of specialized research agents assembled for the topic.",
            items: {
              type: Type.OBJECT,
              properties: {
                id: { type: Type.STRING, description: "A unique short alphanumeric ID for the agent, e.g. agent-1" },
                name: { type: Type.STRING, description: "A unique, creative persona name for the specialist agent" },
                role: { type: Type.STRING, description: "A specialty title a real expert in this exact problem space would hold" },
                investigativeAngle: { type: Type.STRING, description: "A specific investigative assignment stating what this agent must find out and which sources/evidence to chase" },
                colorTheme: { type: Type.STRING, description: "A color name matching their role (choose one of: cyan, emerald, rose, amber, purple, indigo, blue, fuchsia)" },
              },
              required: ["id", "name", "role", "investigativeAngle", "colorTheme"],
            },
          }
        },
        required: ["needAnalysis", "agents"]
      };

      // Some models wrap each agent one level deep ({"agent-1": {...}}) —
      // unwrap before validating.
      const normalizeAgentItem = (a: any): any => {
        if (!a || typeof a !== "object") return a;
        if (!a.name && !a.role && !a.investigativeAngle) {
          const vals = Object.values(a);
          if (vals.length === 1 && vals[0] && typeof vals[0] === "object") return vals[0];
        }
        return a;
      };
      const isUsableAgent = (a: any): boolean =>
        !!a && typeof a === "object" &&
        typeof a.investigativeAngle === "string" && a.investigativeAngle.trim().length > 0 &&
        ((typeof a.name === "string" && a.name.trim().length > 0) || (typeof a.role === "string" && a.role.trim().length > 0));

      // Some models echo the schema back with the real data nested inside
      // (e.g. {properties: {agents: {items: [...]}}}) — breadth-first scan for
      // the first array that actually contains usable agents.
      const findAgentArrayDeep = (root: any): any[] => {
        const queue: any[] = [root];
        let guard = 0;
        while (queue.length > 0 && guard++ < 300) {
          const node = queue.shift();
          if (!node || typeof node !== "object") continue;
          if (Array.isArray(node)) {
            const normalized = node.map(normalizeAgentItem).filter(isUsableAgent);
            if (normalized.length >= 2) return normalized;
            for (const v of node) queue.push(v);
          } else {
            for (const v of Object.values(node)) queue.push(v);
          }
        }
        return [];
      };

      const findNeedAnalysisDeep = (root: any): string => {
        const queue: any[] = [root];
        let guard = 0;
        while (queue.length > 0 && guard++ < 300) {
          const node = queue.shift();
          if (!node || typeof node !== "object" || Array.isArray(node)) {
            if (Array.isArray(node)) for (const v of node) queue.push(v);
            continue;
          }
          const val = node.needAnalysis;
          if (typeof val === "string" && val.trim()) return val.trim();
          if (val && typeof val === "object" && typeof val.value === "string" && val.value.trim()) return val.value.trim();
          for (const v of Object.values(node)) if (v && typeof v === "object") queue.push(v);
        }
        return "";
      };

      // Silently shipping placeholder "Specialist N" agents when a model goes
      // off-schema defeats the whole need-driven design — validate and retry
      // once with a corrective instruction instead.
      let agentsList: any[] = [];
      let needAnalysis = "";
      let lastError: any = null;
      for (let attempt = 1; attempt <= 2; attempt++) {
        const attemptPrompt = attempt === 1
          ? prompt
          : `${prompt}\n\nIMPORTANT: Your previous response did not match the required JSON schema. Return ONLY a single raw JSON object — no schema echo, no markdown, nothing after the closing brace — with a "needAnalysis" string and an "agents" array of FLAT objects, each having exactly these string keys: id, name, role, investigativeAngle, colorTheme.`;

        let result: any = null;
        try {
          result = await generateUnifiedJSON("orchestrator", settings, attemptPrompt, systemInstruction, responseSchema);
        } catch (err: any) {
          lastError = err;
          console.warn(`[Initiate] Attempt ${attempt}: orchestrator response unparseable — ${err.message}`);
          continue;
        }

        let list: any[] = [];
        if (result) {
          if (Array.isArray(result)) {
            list = result;
          } else if (Array.isArray(result.agents)) {
            list = result.agents;
          } else if (typeof result === "object") {
            // Robust fallback: find any array property in the returned object
            const foundArray = Object.values(result).find(val => Array.isArray(val));
            if (foundArray) {
              list = foundArray as any[];
            } else if (result.agents && typeof result.agents === "object") {
              // Some models return agents as an object map instead of an array
              list = Object.values(result.agents);
            }
          }
        }

        list = list.map(normalizeAgentItem).filter(isUsableAgent);
        // Schema-echo and other nesting mishaps: hunt for the agents wherever
        // the model buried them before burning a retry.
        if (list.length < 2 && result && typeof result === "object") {
          list = findAgentArrayDeep(result);
        }

        if (list.length >= 2) {
          agentsList = list;
          needAnalysis = result && typeof result.needAnalysis === "string"
            ? result.needAnalysis.trim()
            : findNeedAnalysisDeep(result);
          break;
        }
        console.warn(`[Initiate] Attempt ${attempt}: orchestrator output unusable (${list.length} valid agents). Raw: ${JSON.stringify(result).slice(0, 800)}`);
      }

      if (agentsList.length === 0) {
        throw new Error(`Orchestrator failed to produce a valid agent roster after a retry — the model returned output that does not match the required structure${lastError ? ` (${lastError.message?.slice(0, 200)})` : ""}. Try a different orchestrator model or provider.`);
      }

      // Safeguard IDs and structure
      const cleanAgents = agentsList.slice(0, 9).map((a: any, idx: number) => ({
        id: a.id || `agent-${idx + 1}`,
        name: a.name || `Specialist ${idx + 1}`,
        role: a.role || "Swarm Investigator",
        investigativeAngle: a.investigativeAngle,
        colorTheme: a.colorTheme || "cyan"
      }));

      res.json({ agents: cleanAgents, needAnalysis, rawTopic, ...(conditioned ? { directive: conditioned } : {}) });
    } catch (error: any) {
      console.error("Error in /api/research/initiate:", error);
      res.status(500).json({ error: error.message || "Failed to assemble research agents." });
    }
  });

  // 1.5. Regenerate Single Agent Endpoint with Nudge
  app.post("/api/research/regenerate-agent", async (req, res) => {
    try {
      const { topic, agents, agentIdToRegenerate, nudge, settings, needAnalysis } = req.body;
      if (!topic || !agents || !agentIdToRegenerate) {
        return res.status(400).json({ error: "Topic, agents list, and agentIdToRegenerate are required." });
      }

      console.log(`Regenerating agent ${agentIdToRegenerate} for topic: "${String(topic).slice(0, 120)}" with nudge: "${nudge || "none"}"`);

      const otherAgents = agents.filter((a: any) => a.id !== agentIdToRegenerate);
      const otherAgentsContext = otherAgents
        .map((a: any) => `- ${a.name} (${a.role}): ${a.investigativeAngle}`)
        .join("\n");

      const prompt = `Topic: "${topic}"
${needAnalysis ? `Mission analysis of the research need (the replacement must serve a real requirement identified here, not a generic template role):\n${needAnalysis}\n` : ""}Existing research team:
${otherAgentsContext || "None"}

The user wants to replace/regenerate the specialist agent node that has ID: "${agentIdToRegenerate}".
${nudge ? `The user provided the following design NUDGE/CRITIQUE to guide this new agent's role and focus: "${nudge}"` : "Please refresh this agent to complement the rest of the team."}

Design a fresh, new replacement research specialist agent.
The replacement agent MUST have a unique, creative name (completely different from other existing agents), a highly specialized role/title, a detailed investigative instruction/angle, and a theme color (one of: cyan, emerald, rose, amber, purple, indigo, blue, fuchsia).
Ensure the new agent is distinct and does not replicate the other existing agents, but complements them perfectly.`;

      const systemInstruction = "You are an elite Research Swarm Orchestrator. Your task is to design a high-fidelity specialized agent to replace an existing node in a research team, strictly adhering to the user's focus nudge.";

      const responseSchema = {
        type: Type.OBJECT,
        properties: {
          id: { type: Type.STRING, description: "Must be the exact ID of the agent being replaced: " + agentIdToRegenerate },
          name: { type: Type.STRING, description: "A unique, creative name for the replacement specialist agent" },
          role: { type: Type.STRING, description: "A detailed role or specialty title for the replacement agent" },
          investigativeAngle: { type: Type.STRING, description: "A specific investigative query/angle addressing the nudge and topic" },
          colorTheme: { type: Type.STRING, description: "A color name (choose one of: cyan, emerald, rose, amber, purple, indigo, blue, fuchsia)" },
        },
        required: ["id", "name", "role", "investigativeAngle", "colorTheme"],
      };

      const replacementAgent = await generateUnifiedJSON("orchestrator", settings, prompt, systemInstruction, responseSchema);
      
      // Make sure the ID is correct
      replacementAgent.id = agentIdToRegenerate;

      res.json({ agent: replacementAgent });
    } catch (error: any) {
      console.error("Error in /api/research/regenerate-agent:", error);
      res.status(500).json({ error: error.message || "Failed to regenerate specialist agent." });
    }
  });

  // 2. Agent Research Run Endpoint - Executes a single agent investigation via SSE
  app.post("/api/research/agent-run-stream", async (req, res) => {
    try {
      const { topic, rawTopic, agent, settings, config, priorContext } = req.body;
      if (!topic || !agent) {
        return res.status(400).json({ error: "Topic and agent configuration are required." });
      }
      req.on("close", () => {
        if (!res.writableEnded) console.warn(`[Client] disconnected mid-stream from agent ${agent.name} — provider call continues to completion.`);
      });
      // Baseline search strings come from the user's short topic, never from
      // a conditioned directive whose first 160 chars are a title line.
      const queryTopic: string = typeof rawTopic === "string" && rawTopic.trim() ? rawTopic.trim() : String(topic);
      // Evidence policy governs the rubric in the prompt AND the search mix.
      const policy = normalizePolicy(config?.evidencePolicy, !!(config && config.fringeMode));

      const depth = config && config.depth ? config.depth : "standard";
      const fringe = !!(config && config.fringeMode);
      const delta = !!(priorContext && priorContext.delta);
      const priorBlock = formatPriorContextBlock(priorContext);

      console.log(`Running streaming agent investigation: ${agent.name} (${agent.role}) for topic: "${String(topic).slice(0, 120)}" [${depth}${fringe ? ", fringe" : ""}${delta ? ", delta" : ""}]`);

      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.flushHeaders();
      res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);

      // Anti-stale-data guardrails: every agent knows today's date, must
      // prefer live web findings over memory, and must cite sources.
      const today = new Date().toDateString();
      const datePreamble = `Today's date is ${today} (local server time; UTC may differ by up to a day, so source timestamps within a day of this date are normal, not anomalies). Your training data predates this — treat live web information as authoritative over memorized knowledge, and date-stamp any claim that could have changed since your training.`;
      const citationRules = `SOURCE RULES: Ground your findings in live web sources retrieved during this investigation and cite them inline (source name + URL). If a point cannot be verified against live sources, explicitly mark it as unverified model knowledge. Absence from your training data is NEVER evidence of absence — do not declare a subject nonexistent or "without evidence" unless live search actually returned nothing relevant, and even then write "live search returned no coverage of this" rather than asserting it does not exist.

EVIDENCE DISCIPLINE (mandatory):
- SCORE YOUR SOURCES inline by CHAIN OF CUSTODY on the 0-10 scale defined in the EVIDENCE POLICY above (10 = you read the primary artifact at a resolvable location … 1-3 = a claim with no artifact behind it). Who published it is context, never the score. Write it inline with the FULL URL, e.g. "(Allan Memorial billing ledger scan, https://archive.org/details/example, 9/10)" — a bare domain is not a citation; every cited source needs a resolvable link.
- TRIANGULATE: a claim confirmed by independent sources is stronger than one echoed by sources citing each other. State which you have, and flag single-source claims as single-source.
- SEEK CONTRADICTION: actively report evidence cutting AGAINST your own emerging conclusion. A report with no counter-evidence is incomplete.
- FOLLOW THE INCENTIVE: where a claim is contested, note who funds, profits from, or is harmed by each position.
- PRESERVE UNCERTAINTY: separate what is established, what is contested, and what is unknown. Do not force a verdict the evidence does not support.`;

      let prompt: string;
      if (depth === "recon") {
        prompt = `You are ${agent.name}, a specialized research agent working as a ${agent.role}.
The overarching research project is: "${topic}".
Your specific investigative assignment is: "${agent.investigativeAngle}".

Deliver a FOCUSED TACTICAL BRIEF of approximately 800-1,200 words. Be sharp, dense, and high-signal. Cut all filler and padding — but never cut evidence: concrete data, dates, and sources stay.
Structure your response with Markdown:
- A brief 'Role Perspective' (2-3 sentences on how a ${agent.role} frames this issue).
- 'Key Findings' as a set of tight, information-rich bullet points.
- 'Critical Insights' capturing the 2-4 most consequential takeaways.
- 'Counter-Evidence & Gaps' — what cuts against your conclusion, what remains contested, and any query that came back empty.

Ground your points in the live web intelligence available to you this run and cite sources. Write in your persona, first person. Prioritize precision over volume.`;
      } else if (depth === "deep") {
        prompt = `You are ${agent.name}, a specialized research agent working as a ${agent.role}.
The overarching research project is: "${topic}".
Your specific investigative assignment is: "${agent.investigativeAngle}".

Conduct an EXTENSIVE, IN-DEPTH investigation based on your role and instructions. You must think deeply, ground your work in the live web intelligence available to you this run, and provide a massive, comprehensive professional specialist report. Do not hold back; elaborate significantly on every point.
Structure your response beautifully with Markdown:
- Use clear headers.
- Include a 'Role Perspective' section detailing how a ${agent.role} uniquely views this issue.
- Include 'Detailed Findings' with robust analysis, structured points, data, and technical breakdowns.
- Include 'Critical Insights' with deep thinking, interconnected consequences, and future implications.
- Include 'Counter-Evidence & Contested Ground' — evidence cutting against your own conclusion, unresolved disputes, who benefits from each position, and any search that came back empty.
- Include 'Methodology & Data Vectors' reporting ONLY the live searches actually executed this run (the exact queries and what they returned). Never describe a search, database, or archive check that did not actually happen.

DEEP-ANALYSIS REQUIREMENTS (mandatory):
- LENGTH FLOOR: at least 5,000-8,000 words. If you must choose, always choose more depth.
- Provide QUANTIFIED data, figures, and estimates wherever possible (ranges, magnitudes, timelines, costs).
- Include AT LEAST ONE Markdown table organizing key data, comparisons, or metrics.
- Include a 'Scenario Analysis' section modeling best-case, base-case, and worst-case trajectories.
- Include a 'Contrarian Considerations' section that challenges the prevailing assumptions of your own analysis.

Be exhaustive, verbose, informative, and write in your persona. Aim for AT LEAST 2,500-4,000 words — a floor, not a ceiling. Do not speak about yourself in the third person. Provide publication-grade, extremely high-quality content.`;
      } else {
        prompt = `You are ${agent.name}, a specialized research agent working as a ${agent.role}.
The overarching research project is: "${topic}".
Your specific investigative assignment is: "${agent.investigativeAngle}".

Conduct an EXTENSIVE, IN-DEPTH investigation based on your role and instructions. You must think deeply, ground your work in the live web intelligence available to you this run, and provide a massive, comprehensive professional specialist report. Do not hold back; elaborate significantly on every point.
Structure your response beautifully with Markdown:
- Use clear headers.
- Include a 'Role Perspective' section detailing how a ${agent.role} uniquely views this issue.
- Include 'Detailed Findings' with robust analysis, structured points, data, and technical breakdowns.
- Include 'Critical Insights' with deep thinking, interconnected consequences, and future implications.
- Include 'Counter-Evidence & Contested Ground' — evidence cutting against your own conclusion, unresolved disputes, who benefits from each position, and any search that came back empty.
- Include 'Methodology & Data Vectors' reporting ONLY the live searches actually executed this run (the exact queries and what they returned). Never describe a search, database, or archive check that did not actually happen.

Be exhaustive, verbose, informative, and write in your persona. Aim for AT LEAST 2,500-4,000 words — a floor, not a ceiling. Do not speak about yourself in the third person. Provide publication-grade, extremely high-quality content.`;
      }

      if (priorBlock) {
        prompt = `${prompt}\n\n${priorBlock}\n\nFOLLOW-UP RULES: The prior findings above are established context — do NOT re-derive or restate them at length. Your job is to EXTEND: chase your specific assignment, verify or challenge prior claims where your assignment demands it, and flag clearly anything you find that contradicts the prior report.`;
        // Sentinel sweeps tighten the mandate further: deltas only, with
        // explicit "no change detected" for stable ground.
        if (delta) {
          prompt = `${prompt}\n\n${DELTA_AGENT_RULES}`;
        }
      }
      if (fringe) {
        prompt = `${prompt}\n\n${FRINGE_AGENT_RULES}`;
      }
      prompt = `${OPERATOR_DIRECTIVES_BLOCK(settings)}${EVIDENCE_POLICY_BLOCK(policy)}\n\n${datePreamble}\n\n${prompt}\n\n${citationRules}`;

      // Queries for the injected-grounding fallback (providers without native
      // web search); native-search providers run their own queries instead.
      // Fringe mode biases the sweep toward archives, declassified records,
      // and practitioner communities alongside a mainstream baseline query.
      const currentYear = new Date().getFullYear();
      const shortTopic = queryTopic.slice(0, 160);
      const naiveQueries = fringe
        ? [
            queryTopic.slice(0, 220),
            String(agent.investigativeAngle || "").slice(0, 220),
            `${shortTopic} site:archive.org`,
            `${shortTopic} declassified FOIA documents`,
            `${shortTopic} forum discussion firsthand account`,
          ].filter((q) => q.trim().length > 0)
        : [
            queryTopic.slice(0, 220),
            String(agent.investigativeAngle || "").slice(0, 220),
            `${shortTopic} latest ${currentYear}`,
          ].filter((q) => q.trim().length > 0);

      // Concretize the mandate into named-entity queries (one extra
      // orchestrator-model call). Keep one raw-topic query as a baseline;
      // fall back to the naive set entirely if planning fails.
      res.write(`data: ${JSON.stringify({ type: "stage", stage: "planning" })}\n\n`);
      const planned = await planSearchQueries(String(topic), String(agent.investigativeAngle || ""), fringe, settings, policy);
      // Exact-phrase and de-glued variants of the topic ride along regardless
      // of planner quality — a niche identifier must always get a direct hunt.
      const topicVariants = buildQueryVariants(queryTopic);
      const searchQueries = planned.length >= 2
        ? [...planned, ...topicVariants]
        : [...naiveQueries, ...topicVariants];
      if (planned.length >= 2) {
        console.log(`[QueryPlan] ${agent.name}: ${planned.map((q) => `"${q}"`).join(" | ")}`);
        // Native-search providers run their own queries — hand them the same
        // concrete anchors through the prompt.
        prompt = `${prompt}\n\nSEARCH PLAN (concrete anchors this investigation must run down and verify via live search): ${planned.join("; ")}`;
      }

      const pingInterval = setInterval(() => {
        res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);
      }, 5000);

      try {
        const { truncated, degenerate } = await runUniversalStream(
          "agent",
          settings,
          prompt,
          `You are ${agent.name}, an expert ${agent.role}. Respond with absolute rigor and intellectual depth, matching your specialized role.`,
          true,
          (text: string) => {
            res.write(`data: ${JSON.stringify({ type: "chunk", text })}\n\n`);
          },
          searchQueries,
          (info) => {
            console.log(`[Grounding] ${agent.name}: ${info.mode} — ${info.detail}`);
            res.write(`data: ${JSON.stringify({ type: "grounding", mode: info.mode, detail: info.detail })}\n\n`);
          },
          true,
          (s) => res.write(`data: ${JSON.stringify({ type: "stage", ...s })}\n\n`),
          { evidencePolicy: policy }
        );

        clearInterval(pingInterval);
        if (degenerate) {
          console.warn(`[Degenerate] ${agent.name}: model emitted blank filler; stream cut at last real text.`);
          res.write(`data: ${JSON.stringify({ type: "chunk", text: DEGENERATE_MARKER })}\n\n`);
        } else if (truncated) {
          console.warn(`[Truncation] ${agent.name}: provider hit its output token limit.`);
          res.write(`data: ${JSON.stringify({ type: "chunk", text: TRUNCATION_MARKER })}\n\n`);
        }
        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
        res.end();
      } catch (error: any) {
        clearInterval(pingInterval);
        throw error;
      }
    } catch (error: any) {
      console.error("Error in /api/research/agent-run-stream:", error);
      res.write(`data: ${JSON.stringify({ type: "error", error: error.message || "Streaming failed." })}\n\n`);
      res.end();
    }
  });

  // 3. Consolidated Synthesis Endpoint - Compiles final synthesis report
  app.post("/api/research/synthesize-stream", async (req, res) => {
    try {
      const { topic, rawTopic, reports: rawReports, settings, config, critiques, priorContext, catalyticTerms } = req.body;
      if (!topic || !rawReports || !Array.isArray(rawReports)) {
        return res.status(400).json({ error: "Topic and reports array are required." });
      }
      // Strip blank filler before anything reads or persists the reports.
      const reports: any[] = rawReports.map((r: any) => (r && typeof r.report === "string" ? { ...r, report: sanitizeReport(r.report) } : r));
      req.on("close", () => {
        if (!res.writableEnded) console.warn("[Client] disconnected mid-synthesis — provider call continues; the run still persists to runs/.");
      });
      const priorBlock = formatPriorContextBlock(priorContext);
      // Short title for the run directory and metadata: the user's original
      // input when the Directive Conditioner expanded it, else the topic.
      const title: string = typeof rawTopic === "string" && rawTopic.trim() ? rawTopic : String(topic);

      const depth = config && config.depth ? config.depth : "standard";
      const fringe = !!(config && config.fringeMode);
      const delta = !!(priorContext && priorContext.delta);
      const policy = normalizePolicy(config?.evidencePolicy, fringe);

      console.log(`Synthesizing ${reports.length} reports for topic: "${title.slice(0, 120)}" via SSE [${depth}${fringe ? ", fringe" : ""}${delta ? ", delta" : ""}]`);

      // Persist the run's inputs immediately — if anything downstream dies
      // (client tab, stream, process), the specialists' work is already safe.
      const runDir = path.join(RUNS_DIR, `${new Date().toISOString().replace(/[:.]/g, "-")}-${slugify(title)}`);
      persistRunFile(runDir, "inputs.json", JSON.stringify({ topic, rawTopic: title, config, critiques, catalyticTerms, reports }, null, 2));

      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.flushHeaders();
      res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);

      const reportsContext = reports
        .filter(r => r && r.report)
        .map((r) => `### AGENT: ${r.agentName || "Specialist"}\n**ROLE:** ${r.agentRole || "Investigator"}\n**FINDINGS:**\n${r.report}\n---\n`)
        .join("\n");

      if (!reportsContext) {
        return res.status(400).json({ error: "No valid specialist reports found to synthesize." });
      }

      console.log(`Synthesis Context size: ${reportsContext.length} chars`);

      // Explicit word FLOORS per depth — without them models default to
      // executive-summary length no matter how rich the specialist material.
      let depthDirective = "";
      if (depth === "recon") {
        depthDirective = "\n\nDEPTH DIRECTIVE — RECON: Produce a SHARP TACTICAL SYNTHESIS of roughly 1,500-2,500 words. Prioritize the highest-signal conclusions and keep every section decision-oriented — but concrete data, prices, dates, and sources still carry forward; concision means cutting filler, never cutting evidence.";
      } else if (depth === "deep") {
        depthDirective = "\n\nDEPTH DIRECTIVE — DEEP: Produce an EXHAUSTIVE synthesis of AT LEAST 8,000-12,000 words — this is a floor, not a ceiling. Maximize retention of technical nuance. Preserve quantified data, edge cases, dissenting views, tables, and scenario analyses surfaced by the specialists. Every theme gets a full-length treatment; if you must choose, always choose more depth.";
      } else {
        depthDirective = "\n\nDEPTH DIRECTIVE — STANDARD: Produce a DENSE, comprehensive synthesis of AT LEAST 4,000-6,000 words — this is a floor, not a ceiling. Do not summarize the specialists' work down to headlines: expand each theme with their actual evidence, numbers, and sources.";
      }

      let critiquesBlock = "";
      let critiqueDirective = "";
      if (Array.isArray(critiques) && critiques.length > 0) {
        const critiquesContext = critiques
          .filter((c: any) => c && c.critique)
          .map((c: any) => `### RED TEAM CRITIQUE OF ${c.agentName || "Specialist"} (${c.agentRole || "Investigator"})\n${c.critique}\n---\n`)
          .join("\n");
        if (critiquesContext) {
          critiquesBlock = `\n\nRED TEAM CRITIQUES:\nThe following adversarial cross-examinations were produced by VEX, Chief Adversarial Officer, who ruthlessly stress-tested each specialist report. Each critique flags weak evidence, blind spots, counter-evidence, and a confidence verdict (High/Medium/Low).\n\n${critiquesContext}`;
          critiqueDirective = `\n\n## 4.5 Red Team Findings & Rebuttals
- VEX reviewed each specialist report WITHOUT web access. Critiques are internal consistency checks on the evidence as written — they are not new evidence and do not outrank a sourced finding.
- Address each material critique in one of three ways: (a) rebut it with specific evidence from the specialist reports; (b) concede it and adjust the affected conclusions elsewhere in this synthesis; or (c) note that it raises a question this sweep did not test, and carry it into the follow-up recommendations. A critique with no evidence behind it earns (c), not a concession.
- Where VEX rated a specialist report Low reliability, state plainly how that bounds the confidence of the conclusions that depend on it.`;
        }
      }

      // Catalytic terms from the pre-synthesis cross-check: loaded names that
      // surfaced in reports without being assigned. Synthesis must address
      // each one — unresolved terms become explicit follow-up threads.
      let catalyticBlock = "";
      let catalyticDirective = "";
      const cleanCatalytic = Array.isArray(catalyticTerms)
        ? catalyticTerms.filter((t: any) => t && typeof t.term === "string" && t.term.trim()).slice(0, 10)
        : [];
      if (cleanCatalytic.length > 0) {
        catalyticBlock = `\n\nCATALYTIC TERMS (flagged by the post-report cross-check — these loaded names surfaced in the specialist reports WITHOUT having been assigned in any investigative angle):\n${cleanCatalytic.map((t: any) => `- "${t.term}"${t.why ? ` — ${String(t.why).slice(0, 300)}` : ""}`).join("\n")}`;
        catalyticDirective = `\n\n## Catalytic Terms Review
- Address EVERY catalytic term listed above explicitly: what the file establishes about it, what remains unexamined, and whether it recurs across domains.
- Any catalytic term the file cannot resolve MUST be emitted as a specific follow-up thread${fringe ? " in the Open Leads section" : " in the further-investigation recommendations"}.`;
      }

      const followUpContextBlock = priorBlock
        ? `\n\n${priorBlock}\n\nThis synthesis concludes a FOLLOW-UP investigation commissioned against the prior findings above.`
        : "";
      const followUpSectionDirective = priorBlock
        ? `\n\n## 4.7 Follow-Up Integration
- This was a follow-up run. State explicitly what the new investigation ADDS to, CONFIRMS in, or OVERTURNS from the prior report.
- Address the user's follow-up directive point by point: what is now answered, and what remains open.
- Where new findings contradict the prior report, say so plainly and state which conclusion should now be trusted and why.`
        : "";

      // The VEX and follow-up directives are numbered for the standard
      // structure; renumber their section headers to sit after the docket's
      // seven sections in fringe mode. Structure is picked by mode, and a
      // sentinel delta sweep WINS over fringe: the sweep's product is the
      // Delta Briefing regardless of the case's original mode. The delta
      // branch deliberately drops followUpSectionDirective — sections 2-5 of
      // the briefing ARE the follow-up integration, so appending it would
      // duplicate the whole document's purpose.
      const structureBody = delta
        ? `${DELTA_SYNTHESIS_STRUCTURE(title)}${critiqueDirective.replace("## 4.5 Red Team Findings & Rebuttals", "## 7. Red Team Findings & Rebuttals")}`
        : fringe
        ? `${FRINGE_SYNTHESIS_STRUCTURE(title)}${critiqueDirective.replace("## 4.5 Red Team Findings & Rebuttals", "## 8. Case Audit — Findings & Responses")}${followUpSectionDirective.replace("## 4.7 Follow-Up Integration", "## 9. Follow-Up Integration")}`
        : `# ${title}: Swarm Intelligence Synthesis

## 1. Executive Summary
- High-level distillation of core discoveries.
- The "Bottom Line Up Front" (BLUF).

## 2. Investigative Tracks & Methodology
- Overview of the parallel expertise utilized in this swarm.
- How the different specialist angles fielded for this particular mission interconnected.

## 3. Synthesized Expert Insights
- Deep-dive analysis categorized by theme.
- Do NOT just list reports. BLEND the insights together to form a coherent narrative.
- Use sub-headers for major thematic pillars.

## 4. Conflict, Consensus & Uncertainty
- Where did specialists agree?
- Where were there disagreements or trade-offs?
- Identify gaps or areas requiring further future investigation.${critiqueDirective}${followUpSectionDirective}

## 5. Strategic Trajectory & Recommendations
- Forward-looking implications.
- Actionable steps or logical consequences.

## 6. Synthesis Conclusion
- Final summarizing statement.`;

      const structureWithCatalytic = `${structureBody}${catalyticDirective}`;

      const prompt = `${OPERATOR_DIRECTIVES_BLOCK(settings)}${EVIDENCE_POLICY_BLOCK(policy)}

OVERARCHING TOPIC: "${topic}"

You are the Lead Swarm Orchestrator. ${fringe
        ? "Your mission is to consolidate the following case-file investigations into a single Evidence Docket. This is an accumulating investigation, not an adjudication: your job is to organize the file, surface its patterns, and keep the case honest — not to force a verdict."
        : "Your mission is to synthesize the following expert investigative reports into a single, comprehensive, publication-grade analytical document."}

SPECIALIST REPORTS:
${reportsContext}${critiquesBlock}${followUpContextBlock}${catalyticBlock}

REQUIRED OUTPUT STRUCTURE:
${structureWithCatalytic}

STYLE GUIDELINES:
${fringe
        ? "- Tone: Investigative, meticulous, non-dismissive. Rigor lives in provenance tags and specificity, not editorial distance."
        : "- Tone: Academic, rigorous, insightful, and authoritative."}
- Depth: Be extremely detailed. Retain the technical nuances from the specialist reports.
- Flow: Ensure a smooth narrative transition between sections.
- Markdown: Use clean, standard Markdown.
- The OVERARCHING TOPIC above may be a full research directive with its own headers and an authoritative-context block. Those are INSTRUCTIONS to satisfy, not content to reproduce: never copy the directive or the context into this document. Start with the required title header below.

DENSITY MANDATE (mandatory, applies to every structure and depth):
${fringe
        ? "- OPEN WITH THE FILE'S STATE: what the evidence currently supports, what it does not, and the strongest open lead — before any background. \"Insufficient to conclude\" is a valid opening. The user's constraints and context CALIBRATE that reading; they are supporting material, never the headline."
        : "- ANSWER THE PRIMARY QUESTION FIRST: open with the direct answer the user asked for — the pick, the ranking, the verdict — before any background. The user's constraints and technical context CALIBRATE the verdict; they are supporting material, never the headline or the organizing frame."}
- Carry the specialists' concrete material FORWARD: numbers, dates, names, prices, direct quotes, and source URLs must survive into this synthesis. Never compress a quantified finding into a vague generalization.
- Organize insights by theme; under each theme, weave together what multiple specialists found and quote their strongest evidence directly.
- Document contradictions verbatim and preserve uncertainty explicitly. Treat significant ABSENCES — what no specialist could find — as findings in their own right, stated plainly.
- NEGATIVE-EXISTENCE DISCIPLINE: never assert that a system, program, name, or acronym "does not exist" or "has no known use" unless the specialist reports show a DEDICATED verification sweep (multiple query variants, acronym expansions, alternate spellings) that came back empty. Anything less MUST be phrased as "not found in this sweep" and emitted as a follow-up thread. Absence of evidence in a limited search is never evidence of absence.
- Append a final section titled "## Source Ledger (scored under ${POLICY_LABEL[policy]})": every distinct source cited anywhere in the specialist reports, organized by CHAIN OF CUSTODY (Artifact in hand 8-10 / Faithful copy or named primary 4-7 / No artifact 1-3), each entry with its URL, its custody score, and one line on what it supports or contradicts. Never tier by publisher.${depthDirective}`;

      const pingInterval = setInterval(() => {
        res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);
      }, 5000);

      try {
        let synthesizedReport = "";
        const { truncated, degenerate } = await runUniversalStream(
          "synthesis",
          settings,
          prompt,
          "You are the Lead Swarm Orchestrator. You specialize in synthesizing multiple distinct, expert perspectives into highly detailed, comprehensive, publication-grade analytical reports. Ensure maximal detail and deep thinking.",
          false,
          (text: string) => {
            synthesizedReport += text;
            res.write(`data: ${JSON.stringify({ type: "chunk", text })}\n\n`);
          },
          undefined,
          undefined,
          undefined,
          (s) => res.write(`data: ${JSON.stringify({ type: "stage", ...s })}\n\n`)
        );

        clearInterval(pingInterval);
        if (degenerate) {
          console.warn("[Degenerate] synthesis: model emitted blank filler; stream cut at last real text.");
          synthesizedReport = sanitizeReport(synthesizedReport) + DEGENERATE_MARKER;
          res.write(`data: ${JSON.stringify({ type: "chunk", text: DEGENERATE_MARKER })}\n\n`);
        } else if (truncated) {
          console.warn("[Truncation] synthesis: provider hit its output token limit.");
          synthesizedReport += TRUNCATION_MARKER;
          res.write(`data: ${JSON.stringify({ type: "chunk", text: TRUNCATION_MARKER })}\n\n`);
        }
        console.log(`Synthesis generation complete. Response text length: ${synthesizedReport.length}`);
        persistRunFile(runDir, "synthesis.md", synthesizedReport);
        persistRunFile(runDir, "meta.json", JSON.stringify({ topic, rawTopic: title, completedAt: new Date().toISOString(), chars: synthesizedReport.length, depth, fringe, delta }, null, 2));
        console.log(`Run persisted to ${runDir}`);
        res.write(`data: ${JSON.stringify({ type: "done", text: synthesizedReport })}\n\n`);
        res.end();
      } catch (error: any) {
        clearInterval(pingInterval);
        throw error;
      }
    } catch (error: any) {
      console.error("Error in /api/research/synthesize-stream:", error);
      res.write(`data: ${JSON.stringify({ type: "error", error: error.message || "Synthesis failed." })}\n\n`);
      res.end();
    }
  });

  // 3.2. Run persistence endpoints — list persisted runs and read a run's
  // files, so finished research is recoverable even after a dead tab.
  app.get("/api/research/runs", (_req, res) => {
    try {
      if (!fs.existsSync(RUNS_DIR)) return res.json({ runs: [] });
      const runs = fs.readdirSync(RUNS_DIR, { withFileTypes: true })
        .filter((d) => d.isDirectory())
        .map((d) => {
          const dir = path.join(RUNS_DIR, d.name);
          let meta: any = null;
          try { meta = JSON.parse(fs.readFileSync(path.join(dir, "meta.json"), "utf8")); } catch {}
          return { id: d.name, hasSynthesis: fs.existsSync(path.join(dir, "synthesis.md")), meta };
        })
        .sort((a, b) => b.id.localeCompare(a.id));
      res.json({ runs });
    } catch (error: any) {
      res.status(500).json({ error: error?.message || "Failed to list runs." });
    }
  });

  app.get("/api/research/runs/:id/:file", (req, res) => {
    try {
      const { id, file } = req.params;
      // Allowlisted filenames + strict id charset = no path traversal.
      if (!/^[a-zA-Z0-9._-]+$/.test(id) || !["synthesis.md", "inputs.json", "meta.json"].includes(file)) {
        return res.status(400).json({ error: "Invalid run id or file." });
      }
      const p = path.join(RUNS_DIR, id, file);
      if (!fs.existsSync(p)) return res.status(404).json({ error: "Not found." });
      res.type(file.endsWith(".json") ? "application/json" : "text/markdown").send(fs.readFileSync(p, "utf8"));
    } catch (error: any) {
      res.status(500).json({ error: error?.message || "Failed to read run file." });
    }
  });

  // 3.2b. Agent portraits — one generated headshot per persona, cached on
  // disk under portraits/<sha1(name|role)>.png and served statically, so a
  // Roster Mode agent keeps the same face across runs. Failure returns a
  // null url and the client keeps its pixel avatar; never blocks a run.
  app.post("/api/research/agent-portrait", async (req, res) => {
    try {
      const { name, role, investigativeAngle, colorTheme, fringe } = req.body || {};
      if (!name || !role) return res.status(400).json({ error: "name and role are required." });
      const key = crypto.createHash("sha1").update(`${String(name).trim().toLowerCase()}|${String(role).trim().toLowerCase()}`).digest("hex");
      const file = path.join(PORTRAITS_DIR, `${key}.png`);
      const url = `/portraits/${key}.png`;
      if (fs.existsSync(file)) return res.json({ url, cached: true });

      const geminiKey = (req.body.settings?.providers?.gemini?.apiKey as string) || process.env.GEMINI_API_KEY || "";
      if (!geminiKey) return res.json({ url: null, error: "No Gemini key for image generation." });

      const accent = PORTRAIT_ACCENTS[String(colorTheme)] || "warm amber";
      const prompt = `Square head-and-shoulders portrait of a fictional specialist named ${name}, a ${role}.
Style: retro-futurist intelligence operative, ${fringe ? "noir case-file investigator, " : ""}painterly with fine film grain, dark warm-black background, strong ${accent} rim light with a soft amber key light, cyber-noir mood, subtle wearable tech or a prop that hints at the role (${String(investigativeAngle || "").slice(0, 160)}).
Composition: face centered, looking just off camera, shoulders up, single subject, no text, no letters, no logos, no watermark, no frame, no border.
The person is invented: do not depict any real or famous individual.`;

      const client = new GoogleGenAI({ apiKey: geminiKey });
      const result = await client.models.generateContent({
        model: PORTRAIT_MODEL,
        contents: prompt,
        config: { responseModalities: ["IMAGE"], imageConfig: { aspectRatio: "1:1" } } as any,
      });
      const parts: any[] = (result as any)?.candidates?.[0]?.content?.parts || [];
      const img = parts.find((p) => p?.inlineData?.data);
      if (!img) return res.json({ url: null, error: "Image model returned no image." });
      fs.mkdirSync(PORTRAITS_DIR, { recursive: true });
      fs.writeFileSync(file, Buffer.from(img.inlineData.data, "base64"));
      console.log(`[Portrait] ${name} (${role}) → ${url}`);
      res.json({ url, cached: false });
    } catch (error: any) {
      console.warn(`[Portrait] failed: ${error?.message || error}`);
      res.json({ url: null, error: error?.message || "Portrait generation failed." });
    }
  });

  // 3.2c. Agent Forge — write (or rewrite) a reusable Library persona from
  // whatever the user typed: a rough description, a bare name, a role, or
  // all three. Uses the "forge" model role (falls back to the orchestrator).
  app.post("/api/research/forge-agent", async (req, res) => {
    try {
      const { name, role, seed, settings, fringe, library } = req.body || {};
      const seedText = String(seed || "").trim();
      const givenName = String(name || "").trim();
      const givenRole = String(role || "").trim();
      if (!seedText && !givenName && !givenRole) {
        return res.status(400).json({ error: "Give the forge something: a description, a name, or a role." });
      }
      const existing = Array.isArray(library)
        ? library.filter((a: any) => a && a.name && a.role).slice(0, 40).map((a: any) => `- ${a.name} — ${a.role}`).join("\n")
        : "";
      const prompt = `You are writing a REUSABLE SPECIALIST PERSONA for a multi-agent research swarm's Agent Library. In Roster Mode the orchestrator reads each persona's STANDING SPECIALTY and tailors a per-mission assignment from it, so the specialty must say what this agent is FOR across many topics — what it hunts, where it looks, what it flags — not a single mission.

HOUSE STYLE for the standing specialty (match it): one tight paragraph of 35-70 words, imperative or declarative, concrete nouns, no fluff. Examples from the library:
- "Hunts hard numbers: datasets, market figures, measurement records, statistical anomalies. Quantifies what others describe, flags where the data is too thin to carry the claims built on it."
- "Follows the money: grants, investors, procurement records, nonprofit filings, and conflicts of interest. Maps who benefits from a claim being believed or buried."
- "Reads patents, technical standards, regulatory filings, and engineering documents — what was actually claimed, what was actually built, and where filings contradict public narratives."

INPUT FROM THE USER:
${givenName ? `Persona name (keep it): "${givenName}"\n` : ""}${givenRole ? `Specialty title (refine only if clearly improvable): "${givenRole}"\n` : ""}${seedText ? `Description / notes (any form — a sentence, keywords, a paragraph, even a full draft to polish):\n"""\n${seedText.slice(0, 3000)}\n"""` : "(no description given — derive the specialty from the name/role)"}
${fringe ? "\nMODE: fringe/case-file research — personas should be investigation-native (archives, FOIA, practitioner communities, provenance), never a 'debunker'." : ""}
${existing ? `\nALREADY IN THE LIBRARY (do not duplicate a role; carve a distinct niche):\n${existing}` : ""}

Return JSON with:
- "name": a short, memorable persona name (one or two words, e.g. "Kestrel", "Mox", "Dr. Ilse Varga"); keep the user's name if given.
- "role": a specialty title a real expert would hold, 2-6 words, Title Case (e.g. "Patent & Technical Filings Examiner").
- "investigativeAngle": the standing specialty in house style, 35-70 words.
- "colorTheme": one of cyan, emerald, rose, amber, purple, indigo, blue, fuchsia — pick what fits the persona.`;
      const responseSchema = {
        type: Type.OBJECT,
        properties: {
          name: { type: Type.STRING },
          role: { type: Type.STRING },
          investigativeAngle: { type: Type.STRING },
          colorTheme: { type: Type.STRING },
        },
        required: ["name", "role", "investigativeAngle", "colorTheme"],
      };
      const result = await generateUnifiedJSON(
        "forge",
        settings,
        prompt,
        "You are the Agent Forge for an investigative research swarm. You write crisp, reusable specialist personas whose standing specialty tells an orchestrator exactly what to hand them on any topic.",
        responseSchema
      );
      const colors = ["cyan", "emerald", "rose", "amber", "purple", "indigo", "blue", "fuchsia"];
      const out = {
        name: String(result?.name || givenName || "").trim().slice(0, 60),
        role: String(result?.role || givenRole || "").trim().slice(0, 80),
        investigativeAngle: String(result?.investigativeAngle || "").trim().slice(0, 900),
        colorTheme: colors.includes(String(result?.colorTheme)) ? String(result.colorTheme) : "cyan",
      };
      if (!out.investigativeAngle) return res.status(502).json({ error: "The forge model returned no specialty text. Try another model in Settings → Agent Forge." });
      console.log(`[Forge] ${out.name} — ${out.role}`);
      res.json({ agent: out });
    } catch (error: any) {
      console.error("Error in /api/research/forge-agent:", error);
      res.status(500).json({ error: error?.message || "Agent forge failed." });
    }
  });

  // 3.3. Catalytic Scan Endpoint — the "snowball" cross-check the swarm's own
  // post-mortem requested: after all reports land, find loaded terms (proper
  // nouns, recurring names/symbols) that surfaced in the reports WITHOUT
  // having been assigned in any investigative angle. Synthesis is then forced
  // to address each one instead of letting it slip through unexamined.
  app.post("/api/research/catalytic-scan", async (req, res) => {
    try {
      const { topic, reports, angles, settings, fringeMode } = req.body;
      if (!Array.isArray(reports) || reports.length === 0) {
        return res.status(400).json({ error: "A non-empty reports array is required." });
      }

      const reportsBlock = reports
        .filter((r: any) => r && r.report)
        .map((r: any) => `### ${r.agentName || "Specialist"} (${r.agentRole || "Investigator"})\n${sanitizeReport(String(r.report)).slice(0, 9000)}`)
        .join("\n\n");
      const anglesBlock = (Array.isArray(angles) ? angles : [])
        .map((a: any) => `- ${String(a).slice(0, 300)}`)
        .join("\n");

      console.log(`Catalytic scan across ${reports.length} reports for topic: "${String(topic).slice(0, 80)}"`);

      const prompt = `TOPIC: "${String(topic).slice(0, 800)}"

ORIGINAL INVESTIGATIVE ASSIGNMENTS (what the team was actually tasked with):
${anglesBlock || "(none provided)"}

SPECIALIST REPORTS:
${reportsBlock}

Identify 3-8 CATALYTIC TERMS: loaded proper nouns, names, numbers, or symbols that (a) appear in the reports above, (b) were NOT named in the original assignments, and (c) warrant a dedicated sweep of their own — especially terms that recur across multiple reports or across domains (a facility name that is also a product name, a symbol that is also a tradition's term of art${fringeMode ? ", an esoteric term with an institutional echo" : ""}).
For each, give the exact term and one sentence on why it is catalytic (where it surfaced and what it might connect). Skip generic vocabulary — only terms a follow-up investigator should chase.`;

      const responseSchema = {
        type: Type.OBJECT,
        properties: {
          terms: {
            type: Type.ARRAY,
            description: "Catalytic terms surfaced by the scan.",
            items: {
              type: Type.OBJECT,
              properties: {
                term: { type: Type.STRING, description: "The exact loaded term/name/symbol" },
                why: { type: Type.STRING, description: "One sentence: where it surfaced and what it might connect" },
              },
              required: ["term", "why"],
            },
          },
        },
        required: ["terms"],
      };

      const result = await generateUnifiedJSON(
        "orchestrator",
        settings,
        prompt,
        "You are a catalytic-term scanner for an investigative research swarm. You spot the loaded names and symbols that surfaced mid-investigation without being assigned — the threads that would otherwise slip through unexamined — with a veteran researcher's nose for cross-domain recurrence.",
        responseSchema
      );
      const rawTerms = Array.isArray(result?.terms) ? result.terms : [];
      const cleanTerms = rawTerms
        .filter((t: any) => t && typeof t.term === "string" && t.term.trim())
        .slice(0, 10)
        .map((t: any) => ({
          term: t.term.trim().slice(0, 80),
          why: typeof t.why === "string" ? t.why.trim().slice(0, 300) : "",
        }));

      res.json({ terms: cleanTerms });
    } catch (error: any) {
      console.error("Error in /api/research/catalytic-scan:", error);
      res.status(500).json({ error: error.message || "Catalytic scan failed." });
    }
  });

  // 3.4. Lead Extraction Endpoint (fringe mode) — pulls the Open Leads out of
  // an Evidence Docket as structured data, and updates the status of leads
  // carried in from a parent case (open → worked / dead-end) based on what
  // this run's docket says about them.
  app.post("/api/research/extract-leads", async (req, res) => {
    try {
      const { synthesis, priorLeads, settings } = req.body;
      if (!synthesis || typeof synthesis !== "string" || !synthesis.trim()) {
        return res.status(400).json({ error: "A non-empty synthesis document is required." });
      }
      const carried = Array.isArray(priorLeads)
        ? priorLeads.filter((l: any) => l && typeof l.text === "string")
        : [];

      console.log(`Extracting case-file leads from docket (${synthesis.length} chars, ${carried.length} carried leads)`);

      const carriedBlock = carried.length
        ? `\nLEADS CARRIED FROM THE PARENT CASE (re-emit every one of these with its id, updating status where this docket shows it was worked or hit a dead end):\n${carried.map((l: any) => `- id "${l.id}" [${l.status || "open"}]: ${l.text}`).join("\n")}\n`
        : "";

      const prompt = `EVIDENCE DOCKET:
${synthesis.slice(0, 30000)}
${carriedBlock}
Extract the case file's leads as structured data:
1. Every lead in the docket's "Open Leads" section becomes a lead with status "open". Keep each lead's text specific and followable (the LEAD + WHY content, condensed to one sentence or two).
2. Every carried lead listed above must be re-emitted with its ORIGINAL id. Set its status to "worked" if this docket shows the thread was pursued and yielded findings, "dead-end" if pursued and exhausted, otherwise keep "open".
3. New leads get ids "lead-<n>" continuing after the highest carried number (or starting at lead-1).
Return 3-12 leads total.`;

      const systemInstruction = "You are a case-file clerk for an investigative research swarm. You extract and maintain the ledger of investigative leads with precision, preserving ids and judging lead status strictly from what the docket states.";

      const responseSchema = {
        type: Type.OBJECT,
        properties: {
          leads: {
            type: Type.ARRAY,
            description: "The full updated lead ledger for this case.",
            items: {
              type: Type.OBJECT,
              properties: {
                id: { type: Type.STRING, description: "Stable lead id, e.g. lead-3. Carried leads keep their original id." },
                text: { type: Type.STRING, description: "The specific, followable thread (1-2 sentences)." },
                status: { type: Type.STRING, description: "One of: open, worked, dead-end" },
              },
              required: ["id", "text", "status"],
            },
          },
        },
        required: ["leads"],
      };

      const result = await generateUnifiedJSON("orchestrator", settings, prompt, systemInstruction, responseSchema);
      const rawLeads = Array.isArray(result?.leads) ? result.leads : Array.isArray(result) ? result : [];
      const cleanLeads = rawLeads
        .filter((l: any) => l && typeof l.text === "string" && l.text.trim())
        .slice(0, 20)
        .map((l: any, idx: number) => ({
          id: typeof l.id === "string" && l.id.trim() ? l.id.trim() : `lead-${idx + 1}`,
          text: l.text.trim(),
          status: ["open", "worked", "dead-end"].includes(l.status) ? l.status : "open",
        }));

      res.json({ leads: cleanLeads });
    } catch (error: any) {
      console.error("Error in /api/research/extract-leads:", error);
      res.status(500).json({ error: error.message || "Failed to extract case leads." });
    }
  });

  // 3.5. Red Team Endpoint - VEX adversarially cross-examines a single specialist report via SSE
  app.post("/api/research/redteam-stream", async (req, res) => {
    try {
      const { topic, agent, report: rawReport, settings, config } = req.body;
      const report = typeof rawReport === "string" ? sanitizeReport(rawReport) : rawReport;
      const rtPolicy = normalizePolicy(config?.evidencePolicy, !!(config && config.fringeMode));
      const rtPrefix = `${OPERATOR_DIRECTIVES_BLOCK(settings)}${EVIDENCE_POLICY_BLOCK(rtPolicy)}\nAudit against THIS policy: a traced practitioner artifact is not a weakness, and an untraced institutional summary is not a strength.\n\n`;
      if (!topic || !agent || !report) {
        return res.status(400).json({ error: "Topic, agent, and report are required for a red team review." });
      }
      const fringe = !!(config && config.fringeMode);

      console.log(`Red Team cross-examination: VEX vs ${agent.name} (${agent.role}) for topic: "${String(topic).slice(0, 120)}"${fringe ? " [fringe: case audit]" : ""}`);

      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.flushHeaders();
      res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);

      const systemInstruction = fringe
        ? "You are VEX, Case Auditor — a meticulous, unsparing evidence-integrity examiner. In fringe case-file mode you audit the FILE, never the subject: your job is chain-of-custody rigor — provenance, contamination, and load-bearing weak points — not topic-level debunking. You never dismiss a subject as inherently unworthy of investigation; you expose exactly how solid each piece of evidence handling actually is."
        : "You are VEX, Chief Adversarial Officer — a ruthless, brilliant red-team analyst. You exist to stress-test intelligence, never to flatter it. You are sharp, specific, and unsparing, but intellectually honest: your objective is to make the final synthesis stronger by exposing every weakness in the specialist's work.";

      const prompt = fringe
        ? `${rtPrefix}OVERARCHING TOPIC: "${topic}"

You are auditing a case-file report submitted by ${agent.name}, a ${agent.role}.
Their assigned investigative angle was: "${agent.investigativeAngle || "n/a"}".

CASE-FILE REPORT UNDER AUDIT:
${report}

Conduct a rigorous evidence audit of this report. Audit the FILE, not the subject — never argue the topic is unworthy of investigation. Be sharp and specific — cite the report's OWN claims and provenance tags when you challenge them. Structure your audit in Markdown with EXACTLY these four sections:

## 1. Provenance & Chain of Custody
Identify claims whose provenance tags overstate their sourcing, citations that do not trace to a locatable source, and secondhand material presented as primary.

## 2. Circular Citation & Contamination
Identify lore citing lore, witness accounts plausibly shaped by prior publications, and single origin points masquerading as multiple independent sources.

## 3. Load-Bearing Weak Points
Identify which specific pieces of evidence the report's overall picture depends on most, assess how solid each actually is, and note any mundane alternative explanations that the file ITSELF suggests.

## 4. Confidence Verdict
State an overall file-integrity verdict of exactly HIGH, MEDIUM, or LOW, followed by a single-sentence justification. Use this exact format: "**Verdict: MEDIUM** — <one-line justification>".

Keep the whole audit tight and high-signal: roughly 400-700 words. Write as VEX, in the first person, with the tone of a scrupulous case supervisor.`
        : `${rtPrefix}OVERARCHING TOPIC: "${topic}"

You are cross-examining a specialist report submitted by ${agent.name}, a ${agent.role}.
Their assigned investigative angle was: "${agent.investigativeAngle || "n/a"}".

SPECIALIST REPORT UNDER REVIEW:
${report}

Conduct a ruthless adversarial cross-examination of this report. Be sharp and specific — cite the report's OWN claims when you attack them. Do not hedge, do not flatter, do not merely summarize the report back. Structure your critique in Markdown with EXACTLY these four sections:

## 1. Weak Evidence & Overreach
Identify claims that are unsupported, speculative, or asserted with more confidence than the evidence warrants. Quote or paraphrase the specific claims you are challenging.

## 2. Blind Spots & Missing Angles
Identify what this report failed to consider — stakeholders, data, counter-scenarios, or second-order effects it ignored.

## 3. Counter-Evidence & Alternative Interpretations
Offer concrete counter-evidence or alternative readings of the same facts that would undercut the report's conclusions.

## 4. Confidence Verdict
State an overall reliability verdict of exactly HIGH, MEDIUM, or LOW, followed by a single-sentence justification. Use this exact format: "**Verdict: MEDIUM** — <one-line justification>".

Keep the whole cross-examination tight and high-signal: roughly 400-700 words. Write as VEX, in the first person, with an incisive prosecutorial tone.`;

      const pingInterval = setInterval(() => {
        res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);
      }, 5000);

      try {
        await runUniversalStream(
          "agent",
          settings,
          prompt,
          systemInstruction,
          false,
          (text: string) => {
            res.write(`data: ${JSON.stringify({ type: "chunk", text })}\n\n`);
          }
        );

        clearInterval(pingInterval);
        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
        res.end();
      } catch (error: any) {
        clearInterval(pingInterval);
        throw error;
      }
    } catch (error: any) {
      console.error("Error in /api/research/redteam-stream:", error);
      res.write(`data: ${JSON.stringify({ type: "error", error: error.message || "Red team review failed." })}\n\n`);
      res.end();
    }
  });

  // 3.6. Claim Atlas Extraction Endpoint — distills a completed run's reports
  // into a structured evidence graph: the major factual claims, which agents'
  // reports support or dispute each one, and the sources cited for it. Plain
  // JSON (not SSE); powers the Claim Atlas overlay in the SPA.
  app.post("/api/research/extract-claims", async (req, res) => {
    try {
      const { reports, synthesizedReport, settings } = req.body;
      const usableReports = Array.isArray(reports)
        ? reports.filter((r: any) => r && typeof r.agentId === "string" && typeof r.report === "string" && r.report.trim())
        : [];
      if (usableReports.length === 0) {
        return res.status(400).json({ error: "At least one specialist report (with agentId) is required." });
      }

      console.log(`Extracting claim atlas from ${usableReports.length} specialist reports`);

      // Bound the payload: deep-depth reports can each run tens of thousands
      // of chars, and the whole set must fit one orchestrator context. Slice
      // rather than reject so extraction always runs.
      const reportsBlock = usableReports
        .map((r: any) => `--- REPORT BY ${r.agentName || r.agentId} (agent id: "${r.agentId}", role: ${r.agentRole || "specialist"}) ---\n${sanitizeReport(r.report).slice(0, 8000)}`)
        .join("\n\n");
      const synthesisBlock = typeof synthesizedReport === "string" && synthesizedReport.trim()
        ? `\n\nSYNTHESIZED REPORT (cross-specialist blend — use it to spot agreement and conflict):\n${synthesizedReport.slice(0, 10000)}`
        : "";

      const validAgentIds: string[] = usableReports.map((r: any) => r.agentId);

      const prompt = `SPECIALIST REPORTS:
${reportsBlock}${synthesisBlock}

Extract the 8-20 MAJOR factual claims made across these reports — the load-bearing assertions a reader would want verified, not throwaway details. For each claim provide:
1. "text": the claim as one clear, self-contained sentence.
2. "theme": a short topical label of 2-4 words grouping related claims. REUSE the same label for claims in the same territory (aim for 3-6 themes total, not one per claim).
3. "supporters": the agent ids whose reports assert or corroborate the claim. Use ONLY these ids: ${validAgentIds.join(", ")}.
4. "disputers": the agent ids whose reports contradict or cast doubt on the claim (an empty array is fine — most claims are undisputed).
5. "sources": 1-4 sources cited for the claim (URLs when the reports give them, otherwise the publication/organization/document names as written).
Every claim needs at least one supporter or disputer. Cover the breadth of the reports; do not let a single specialist dominate the atlas.`;

      const systemInstruction = "You are an evidence cartographer for a research swarm. You map which specialists stand behind which factual claims and which push back, judging support and dispute strictly from what the reports actually say — never from your own knowledge of the topic.";

      const responseSchema = {
        type: Type.OBJECT,
        properties: {
          claims: {
            type: Type.ARRAY,
            description: "The major factual claims across the reports, with per-claim backing.",
            items: {
              type: Type.OBJECT,
              properties: {
                id: { type: Type.STRING, description: "Stable claim id, e.g. claim-3" },
                text: { type: Type.STRING, description: "The claim as one clear, self-contained sentence." },
                theme: { type: Type.STRING, description: "Short topical grouping label (2-4 words), shared by related claims." },
                supporters: { type: Type.ARRAY, description: "Agent ids whose reports support the claim.", items: { type: Type.STRING } },
                disputers: { type: Type.ARRAY, description: "Agent ids whose reports dispute the claim (may be empty).", items: { type: Type.STRING } },
                sources: { type: Type.ARRAY, description: "1-4 cited sources: URLs or source names.", items: { type: Type.STRING } },
              },
              required: ["id", "text", "theme", "supporters", "disputers", "sources"],
            },
          },
        },
        required: ["claims"],
      };

      const result = await generateUnifiedJSON("orchestrator", settings, prompt, systemInstruction, responseSchema);
      const rawClaims = Array.isArray(result?.claims) ? result.claims : Array.isArray(result) ? result : [];

      // Models occasionally emit agent NAMES where ids were asked for — map
      // them back to ids instead of dropping the edge.
      const idSet = new Set(validAgentIds);
      const nameToId = new Map<string, string>(
        usableReports.map((r: any) => [String(r.agentName || "").trim().toLowerCase(), r.agentId] as [string, string])
      );
      const toAgentIds = (arr: any): string[] => {
        if (!Array.isArray(arr)) return [];
        const mapped = arr
          .filter((v: any) => typeof v === "string" && v.trim())
          .map((v: string) => (idSet.has(v.trim()) ? v.trim() : nameToId.get(v.trim().toLowerCase()) || ""))
          .filter((v: string) => v !== "");
        return [...new Set(mapped)];
      };

      const cleanClaims = rawClaims
        .filter((c: any) => c && typeof c.text === "string" && c.text.trim())
        .slice(0, 24)
        .map((c: any, idx: number) => ({
          // Ids are reissued sequentially (claim-1...) — unlike leads they never
          // carry across sessions, so uniqueness matters more than model output.
          id: `claim-${idx + 1}`,
          text: c.text.trim(),
          theme: typeof c.theme === "string" && c.theme.trim() ? c.theme.trim() : "General",
          supporters: toAgentIds(c.supporters),
          disputers: toAgentIds(c.disputers),
          sources: Array.isArray(c.sources)
            ? [...new Set(c.sources.filter((s: any) => typeof s === "string" && s.trim()).map((s: string) => s.trim()))].slice(0, 4)
            : [],
        }))
        // A claim no agent stands behind (or against) has no edges — it is
        // unrenderable in the atlas, so drop it.
        .filter((c: any) => c.supporters.length > 0 || c.disputers.length > 0);

      res.json({ claims: cleanClaims });
    } catch (error: any) {
      console.error("Error in /api/research/extract-claims:", error);
      res.status(500).json({ error: error.message || "Failed to extract the claim atlas." });
    }
  });

  // 4. Interrogation Room Endpoint - Chat with the completed swarm via SSE (grounded, no web search)
  app.post("/api/research/interrogate-stream", async (req, res) => {
    try {
      const { topic, question, respondent, agents, synthesizedReport, chatHistory, settings } = req.body;

      if (!question || typeof question !== "string" || !question.trim()) {
        return res.status(400).json({ error: "A non-empty question is required." });
      }
      if (!agents || !Array.isArray(agents) || agents.length === 0) {
        return res.status(400).json({ error: "A non-empty agents array is required." });
      }

      const isPanel = respondent === "panel";
      const targetAgent = isPanel ? null : agents.find((a: any) => a && a.id === respondent);

      console.log(`Interrogating swarm [${isPanel ? "PANEL" : (targetAgent ? targetAgent.name : respondent)}] for topic: "${String(topic).slice(0, 120)}"`);

      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.flushHeaders();
      res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);

      // Build the grounding intelligence dossier
      let intelligence = "";
      if (isPanel) {
        intelligence += `## CONSOLIDATED SYNTHESIS\n${synthesizedReport || "(no synthesis available)"}\n\n`;
        intelligence += agents
          .filter((a: any) => a && a.report)
          .map((a: any) => `## SPECIALIST REPORT — ${a.name} (${a.role})\nInvestigative angle: ${a.investigativeAngle || "n/a"}\n\n${sanitizeReport(String(a.report))}`)
          .join("\n\n---\n\n");
      } else {
        intelligence += `## CONSOLIDATED SYNTHESIS (shared context)\n${(synthesizedReport || "(no synthesis available)").slice(0, 8000)}\n\n`;
        if (targetAgent) {
          intelligence += `## YOUR OWN FULL REPORT — ${targetAgent.name} (${targetAgent.role})\nInvestigative angle: ${targetAgent.investigativeAngle || "n/a"}\n\n${targetAgent.report || "(no report on file)"}`;
        }
      }

      const history = Array.isArray(chatHistory) ? chatHistory.slice(-8) : [];
      const historyBlock = history.length
        ? "\n\nPRIOR CONVERSATION:\n" + history.map((m: any) => `${m.role === "user" ? "USER" : (m.speaker || "SWARM")}: ${m.content}`).join("\n")
        : "";

      let systemInstruction: string;
      let prompt: string;
      let taskRole: "synthesis" | "agent";

      if (isPanel) {
        taskRole = "synthesis";
        systemInstruction = "You are the Swarm Intelligence panel — the collective voice of the specialist agents plus the lead orchestrator who synthesized their findings. You answer follow-up interrogations strictly from the intelligence already gathered, never from outside knowledge.";
        prompt = `${OPERATOR_DIRECTIVES_BLOCK(settings)}TOPIC: "${topic}"

A user is interrogating the swarm with a follow-up question. The intelligence dossier below is your primary source. If LIVE WEB SEARCH RESULTS were provided above, use them to VERIFY, UPDATE, or CHALLENGE the dossier where the question calls for it — and ALWAYS label which statements come from the dossier versus the live check.

INTELLIGENCE DOSSIER:
${intelligence}${historyBlock}

USER QUESTION: "${question}"

RESPONSE REQUIREMENTS:
- Answer from the dossier plus any live check results, clearly attributing each. If the dossier and the live check disagree, say so plainly — the live check wins on current facts. If neither covers the question, state exactly what is missing and name which specialist angle (by role) would need a follow-up investigation to close the gap.
- Attribute key points to the specialists who made them, by name, where relevant (e.g., "Dr. Vance's analysis indicates..."). Surface where the specialists agree and where they diverge.
- Keep the answer focused and high-signal: roughly 500-1200 words in clean, standard Markdown.`;
      } else {
        taskRole = "agent";
        const name = targetAgent?.name || "Specialist";
        const role = targetAgent?.role || "Investigator";
        systemInstruction = `You are ${name}, an expert ${role} who investigated this topic as part of a research swarm. You are being interrogated directly about your findings. Stay fully in persona and answer only from the intelligence you gathered.`;
        prompt = `${OPERATOR_DIRECTIVES_BLOCK(settings)}TOPIC: "${topic}"

A user is interrogating you directly about your investigation. Stay fully in persona: answer in the FIRST PERSON, in your own voice and expertise as a ${role}. Your own report is your primary source and the synthesis is shared context. If LIVE WEB SEARCH RESULTS were provided above, use them to VERIFY, UPDATE, or CHALLENGE your own findings where the question calls for it — and ALWAYS label which statements come from your report versus the live check. Do not invent facts beyond these sources.

YOUR INVESTIGATION & SHARED CONTEXT:
${intelligence}${historyBlock}

USER QUESTION: "${question}"

RESPONSE REQUIREMENTS:
- Respond in character as ${name}, first person, drawing on your expertise as a ${role}.
- Answer from your report plus any live check results, clearly attributing each. If the live check contradicts your report, concede it plainly — current facts win. If neither covers the question, say so directly and suggest which angle — yours or a colleague's — would need a follow-up investigation.
- Keep it focused and high-signal: roughly 500-1200 words in clean, standard Markdown.`;
      }

      const pingInterval = setInterval(() => {
        res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);
      }, 5000);

      // Live verification: the question plus exact-phrase topic variants get
      // a real search, so interrogation can check the dossier against the
      // world instead of circling inside it.
      const interrogationQueries = [
        String(question).slice(0, 140),
        ...buildQueryVariants(String(topic || "")),
      ];

      try {
        await runUniversalStream(
          taskRole,
          settings,
          prompt,
          systemInstruction,
          true,
          (text: string) => {
            res.write(`data: ${JSON.stringify({ type: "chunk", text })}\n\n`);
          },
          interrogationQueries,
          (info) => {
            console.log(`[Grounding] Interrogation: ${info.mode} — ${info.detail}`);
          }
        );

        clearInterval(pingInterval);
        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
        res.end();
      } catch (error: any) {
        clearInterval(pingInterval);
        throw error;
      }
    } catch (error: any) {
      console.error("Error in /api/research/interrogate-stream:", error);
      res.write(`data: ${JSON.stringify({ type: "error", error: error.message || "Interrogation failed." })}\n\n`);
      res.end();
    }
  });

  // 5. War Room Endpoint - one debate turn: a specialist argues the contested
  // question in persona, rebutting the latest points on the floor, grounded
  // strictly in their own report + the synthesis. The client runs the round
  // loop and streams each turn into the Interrogation Room chat.
  app.post("/api/research/debate-turn-stream", async (req, res) => {
    try {
      const { topic, question, speaker, opponents, synthesizedReport, transcript, settings, round, totalRounds } = req.body;

      if (!question || typeof question !== "string" || !question.trim()) {
        return res.status(400).json({ error: "A non-empty contested question is required." });
      }
      if (!speaker || !speaker.name) {
        return res.status(400).json({ error: "A speaker agent is required." });
      }

      console.log(`War Room turn: ${speaker.name} (round ${round}/${totalRounds}) on "${question.slice(0, 80)}"`);

      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.flushHeaders();
      res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);

      const opponentList = Array.isArray(opponents) && opponents.length
        ? opponents.map((o: any) => `${o.name} (${o.role})`).join(", ")
        : "the other specialists";

      const transcriptBlock = Array.isArray(transcript) && transcript.length
        ? transcript
            .slice(-12)
            .map((t: any) => `${t.speaker || "MODERATOR"}: ${String(t.content || "").slice(0, 1500)}`)
            .join("\n\n")
        : "(you are opening the debate)";

      const isFinalRound = Number(round) >= Number(totalRounds);

      const systemInstruction = `You are ${speaker.name}, an expert ${speaker.role}, debating fellow specialists in the War Room. You argue YOUR evidence-based position with conviction and intellectual honesty: you rebut specifics, concede weak points plainly, and never invent facts beyond the intelligence you gathered.`;

      const prompt = `${OPERATOR_DIRECTIVES_BLOCK(settings)}TOPIC: "${topic}"

CONTESTED QUESTION ON THE FLOOR: "${question}"

You are debating: ${opponentList}. The moderator (the user) may interject — address moderator points directly when they appear.

YOUR OWN FULL REPORT (your authoritative evidence base):
${sanitizeReport(String(speaker.report || "(no report on file)")).slice(0, 14000)}

CONSOLIDATED SYNTHESIS (shared context):
${String(synthesizedReport || "(none)").slice(0, 8000)}

DEBATE TRANSCRIPT SO FAR:
${transcriptBlock}

THIS IS ROUND ${round} OF ${totalRounds}. Deliver your next debate turn:
- Speak in the FIRST PERSON as ${speaker.name}, in your own expert voice. This is a live exchange, not a report — direct, pointed, conversational.
- REBUT the most recent opposing points BY NAME: quote or paraphrase the specific claim you are challenging, then counter it with specific evidence from YOUR report.
- Advance your own strongest point that has not yet been made on the floor.
- Concede honestly where an opponent's evidence beats yours — then explain what that concession does and does not change.
- Ground everything strictly in your report and the synthesis. No new outside facts.
- Keep it tight: 200-350 words.${isFinalRound ? `\n- This is the FINAL round: end with a one-line sharpened stance, formatted exactly as "**Position:** <single sentence>".` : ""}`;

      const pingInterval = setInterval(() => {
        res.write(`data: ${JSON.stringify({ type: "ping" })}\n\n`);
      }, 5000);

      try {
        await runUniversalStream(
          "agent",
          settings,
          prompt,
          systemInstruction,
          false,
          (text: string) => {
            res.write(`data: ${JSON.stringify({ type: "chunk", text })}\n\n`);
          }
        );

        clearInterval(pingInterval);
        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
        res.end();
      } catch (error: any) {
        clearInterval(pingInterval);
        throw error;
      }
    } catch (error: any) {
      console.error("Error in /api/research/debate-turn-stream:", error);
      res.write(`data: ${JSON.stringify({ type: "error", error: error.message || "Debate turn failed." })}\n\n`);
      res.end();
    }
  });

  // Vite middleware / client routing setup
  if (process.env.NODE_ENV !== "production") {
    const vite = await createViteServer({
      server: { middlewareMode: true },
      appType: "spa",
    });
    app.use(vite.middlewares);
  } else {
    const distPath = path.join(process.cwd(), "dist");
    app.use(express.static(distPath));
    app.get("*", (req, res) => {
      res.sendFile(path.join(distPath, "index.html"));
    });
  }

  // The base port may already be taken by other local services (Docker
  // containers, Open WebUI, etc.) — walk upward to the first free port.
  // On Windows, Docker Desktop's port proxy doesn't hold ports exclusively,
  // so a second bind can "succeed" without EADDRINUSE. Binding alone is not
  // a reliable test: probe each candidate and skip any port that answers.
  const isPortServing = (port: number) =>
    new Promise<boolean>((resolve) => {
      const probe = net.connect({ port, host: "127.0.0.1" });
      const done = (taken: boolean) => {
        probe.destroy();
        resolve(taken);
      };
      probe.once("connect", () => done(true));
      probe.once("error", () => done(false));
      probe.setTimeout(400, () => done(false));
    });

  let freePort = BASE_PORT;
  while (await isPortServing(freePort)) {
    console.log(`Port ${freePort} is already in use — trying ${freePort + 1}`);
    freePort++;
    if (freePort > BASE_PORT + 20) {
      console.error(`No free port found in range ${BASE_PORT}-${BASE_PORT + 20}.`);
      process.exit(1);
    }
  }

  const listenOn = (port: number, attemptsLeft: number) => {
    const server = app.listen(port, "0.0.0.0", () => {
      console.log(`Server running on http://localhost:${port}`);
      for (const infos of Object.values(os.networkInterfaces())) {
        for (const info of infos || []) {
          if (info.family === "IPv4" && !info.internal) {
            console.log(`  LAN: http://${info.address}:${port}`);
          }
        }
      }
    });
    server.on("error", (err: NodeJS.ErrnoException) => {
      if (err.code === "EADDRINUSE" && attemptsLeft > 0) {
        console.log(`Port ${port} is in use — trying ${port + 1}`);
        listenOn(port + 1, attemptsLeft - 1);
      } else {
        throw err;
      }
    });
  };
  listenOn(freePort, 20);
}

// Never die silently. A long LLM call that rejects outside an awaited chain
// would otherwise take the process down with nothing on the console.
process.on("uncaughtException", (err: any) => {
  console.error(`[FATAL] uncaughtException: ${err?.stack || err}`);
});
process.on("unhandledRejection", (reason: any) => {
  console.error(`[FATAL] unhandledRejection: ${reason?.stack || reason}`);
});
process.on("exit", (code) => {
  console.error(`[EXIT] process exiting with code ${code} at ${new Date().toISOString()}`);
});
for (const sig of ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"] as NodeJS.Signals[]) {
  try {
    process.on(sig, () => {
      console.error(`[EXIT] received ${sig} at ${new Date().toISOString()}`);
      process.exit(0);
    });
  } catch {
    // Signal not supported on this platform.
  }
}

startServer();