llm-kb 0.4.2 → 0.6.0

package/bin/chunk-Y2764FFH.js

@@ -0,0 +1,1356 @@
+import {
+  completeSimple,
+  continueKBSession,
+  createKBSession,
+  getApiKeyForProvider,
+  getNodeModulesPath,
+  resolveModelCandidates
+} from "./chunk-3WBSKCCH.js";
+
+// src/query.ts
+import {
+  createAgentSession,
+  createBashTool,
+  createReadTool,
+  createWriteTool,
+  DefaultResourceLoader,
+  SettingsManager
+} from "@mariozechner/pi-coding-agent";
+
+// src/retrying-session.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "Unknown error");
+}
+function isRetryableProviderError(error) {
+  const message = getErrorMessage(error).toLowerCase();
+  return [
+    "401",
+    "403",
+    "429",
+    "quota",
+    "credit",
+    "rate limit",
+    "overloaded",
+    "overload",
+    "unavailable",
+    "timeout",
+    "timed out",
+    "network",
+    "connection",
+    "provider",
+    "api key",
+    "authentication",
+    "unauthorized",
+    "forbidden"
+  ].some((term) => message.includes(term));
+}
+async function createRetryingSession(options) {
+  const { createSession, candidates, validatePromptResult, onRetry } = options;
+  if (candidates.length === 0) throw new Error("No usable models available");
+  let candidateIndex = 0;
+  let current = await createSession(candidates[candidateIndex]);
+  let sessionName;
+  const subscribers = [];
+  const attachSubscribers = (session) => {
+    for (const sub of subscribers) session.subscribe(sub);
+  };
+  const swapTo = async (nextIndex) => {
+    const prev = current;
+    candidateIndex = nextIndex;
+    current = await createSession(candidates[candidateIndex]);
+    if (sessionName) current.setSessionName(sessionName);
+    attachSubscribers(current);
+    prev.dispose();
+  };
+  const proxy = {
+    get sessionId() {
+      return current.sessionId;
+    },
+    get sessionFile() {
+      return current.sessionFile;
+    },
+    get state() {
+      return current.state;
+    },
+    subscribe(fn) {
+      subscribers.push(fn);
+      return current.subscribe(fn);
+    },
+    async prompt(text) {
+      let lastError;
+      for (let i = candidateIndex; i < candidates.length; i++) {
+        if (i !== candidateIndex) await swapTo(i);
+        const beforeMessageCount = Array.isArray(current.state?.messages) ? current.state.messages.length : 0;
+        try {
+          const result = await current.prompt(text);
+          const validationError = validatePromptResult?.(current, beforeMessageCount);
+          if (!validationError) return result;
+          const next = candidates[i + 1];
+          const error = new Error(validationError);
+          lastError = error;
+          if (!next) throw error;
+          onRetry?.({
+            from: candidates[i],
+            to: next,
+            error,
+            attempt: i + 2
+          });
+          continue;
+        } catch (error) {
+          lastError = error;
+          const next = candidates[i + 1];
+          if (!next || !isRetryableProviderError(error)) throw error;
+          onRetry?.({
+            from: candidates[i],
+            to: next,
+            error,
+            attempt: i + 2
+          });
+        }
+      }
+      throw lastError instanceof Error ? lastError : new Error(getErrorMessage(lastError));
+    },
+    async reload() {
+      return current.reload();
+    },
+    setSessionName(name) {
+      sessionName = name;
+      return current.setSessionName(name);
+    },
+    dispose() {
+      return current.dispose();
+    }
+  };
+  return proxy;
+}
+
+// src/query.ts
+import { readdir as readdir3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4, readdirSync, readFileSync } from "fs";
+
+// src/trace-builder.ts
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, basename as pathBasename } from "path";
+async function buildTrace(sessionFile, sourcesDir) {
+  const raw = await readFile(sessionFile, "utf-8");
+  const lines = raw.trim().split("\n").filter(Boolean);
+  if (lines.length < 2) return null;
+  const entries = [];
+  let header = null;
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "session") header = obj;
+      else entries.push(obj);
+    } catch {
+    }
+  }
+  if (!header) return null;
+  const messages = entries.filter((e) => e.type === "message");
+  const lastAssistant = [...messages].reverse().find(
+    (e) => e.message?.role === "assistant" && e.message?.stopReason === "stop"
+  );
+  if (!lastAssistant) return null;
+  const modelChange = entries.find((e) => e.type === "model_change");
+  const model = modelChange?.modelId ?? lastAssistant.message?.model ?? void 0;
+  const firstUser = messages.find((e) => e.message?.role === "user");
+  const question = extractText(firstUser?.message?.content);
+  const sessionInfo = entries.find((e) => e.type === "session_info");
+  const sessionName = sessionInfo?.name ?? "";
+  const mode = sessionName.startsWith("index:") ? "index" : sessionName.startsWith("query:") || question ? "query" : "unknown";
+  const answer = extractText(lastAssistant.message?.content);
+  const filesRead = [];
+  for (const entry of messages) {
+    if (entry.message?.role !== "assistant") continue;
+    for (const block of entry.message?.content ?? []) {
+      if (block.type === "toolCall" && block.name === "read") {
+        const p = block.arguments?.path ?? "";
+        if (p && !filesRead.includes(p)) filesRead.push(p);
+      }
+    }
+  }
+  let filesAvailable = [];
+  try {
+    const all = await readdir(sourcesDir);
+    filesAvailable = all.filter((f) => f.endsWith(".md"));
+  } catch {
+  }
+  const filesSkipped = filesAvailable.filter(
+    (f) => !filesRead.some((r) => r.endsWith(f))
+  );
+  const firstMsg = messages[0];
+  const lastMsg = messages[messages.length - 1];
+  let durationMs;
+  if (firstMsg?.timestamp && lastMsg?.timestamp) {
+    durationMs = new Date(lastMsg.timestamp).getTime() - new Date(firstMsg.timestamp).getTime();
+  }
+  return {
+    sessionId: header.id,
+    sessionFile: pathBasename(sessionFile),
+    timestamp: header.timestamp,
+    mode,
+    question: question || void 0,
+    answer: answer || void 0,
+    filesRead,
+    filesAvailable,
+    filesSkipped,
+    model,
+    durationMs
+  };
+}
+async function saveTrace(kbRoot, trace) {
+  const tracesDir = join(kbRoot, ".llm-kb", "traces");
+  await mkdir(tracesDir, { recursive: true });
+  const outPath = join(tracesDir, `${trace.sessionId}.json`);
+  await writeFile(outPath, JSON.stringify(trace, null, 2) + "\n", "utf-8");
+}
+async function appendToQueryLog(kbRoot, trace) {
+  if (trace.mode !== "query" || !trace.question) return;
+  const wikiDir = join(kbRoot, ".llm-kb", "wiki");
+  await mkdir(wikiDir, { recursive: true });
+  const logPath = join(wikiDir, "queries.md");
+  const date = new Date(trace.timestamp).toISOString().replace("T", " ").slice(0, 19);
+  const durationSec = trace.durationMs ? `${(trace.durationMs / 1e3).toFixed(1)}s` : "?";
+  const filesLine = trace.filesRead.length > 0 ? trace.filesRead.map((f) => pathBasename(f)).join(", ") : "_none_";
+  let header = "";
+  if (!existsSync(logPath)) {
+    header = `# Query Log
+
+All queries run against this knowledge base.
+
+---
+
+`;
+  }
+  const entry = [
+    `## ${trace.question}`,
+    ``,
+    `- **Date:** ${date}`,
+    `- **Model:** ${trace.model ?? "unknown"}`,
+    `- **Duration:** ${durationSec}`,
+    `- **Files read:** ${filesLine}`,
+    trace.filesSkipped.length > 0 ? `- **Files skipped:** ${trace.filesSkipped.join(", ")}` : null,
+    ``,
+    trace.answer ? `### Answer
+
+${trace.answer}` : null,
+    ``,
+    `---`,
+    ``
+  ].filter((l) => l !== null).join("\n");
+  const existing = existsSync(logPath) ? await readFile(logPath, "utf-8") : "";
+  await writeFile(logPath, header + entry + existing, "utf-8");
+}
+function extractText(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("").trim();
+  }
+  return "";
+}
+
+// src/citations.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function parseCitations(agentResponse) {
+  const citationsIdx = agentResponse.search(/^CITATIONS:\s*$/im);
+  if (citationsIdx < 0) {
+    return { answer: agentResponse, citations: [] };
+  }
+  const answer = agentResponse.slice(0, citationsIdx).trimEnd();
+  const citationsBlock = agentResponse.slice(citationsIdx);
+  const citations = [];
+  const lineRe = /^\s*(?:-\s*)?(?:\[\d+\]\s*)?file:\s*"([^"]+)"\s*,\s*page(s)?:\s*(\[[^\]]+\]|\d+)\s*,\s*quote:\s*"([^"]+)"(.*)/gm;
+  let match;
+  while ((match = lineRe.exec(citationsBlock)) !== null) {
+    const file = match[1];
+    const isMultiPage = match[2] === "s";
+    const pageStr = match[3].trim();
+    const quote = match[4];
+    const rest = match[5] || "";
+    const citation = { file, page: 0, quote };
+    if (isMultiPage) {
+      const pageNums = pageStr.replace(/[\[\]]/g, "").split(/\s*,\s*/).map(Number).filter((n) => !isNaN(n));
+      citation.page = pageNums[0] || 0;
+      const bboxArrayMatch = rest.match(/bbox:\s*\[([^\]]+)\]/);
+      if (bboxArrayMatch) {
+        const entries = bboxArrayMatch[1].split(/\}\s*,\s*\{/);
+        const pageBBoxes = [];
+        for (const entry of entries) {
+          const clean = entry.replace(/[{}]/g, "");
+          const pM = clean.match(/page:\s*(\d+)/);
+          const xM = clean.match(/x:\s*([\d.]+)/);
+          const yM = clean.match(/y:\s*([\d.]+)/);
+          const wM = clean.match(/width:\s*([\d.]+)/);
+          const hM = clean.match(/height:\s*([\d.]+)/);
+          if (pM && xM && yM && wM && hM) {
+            pageBBoxes.push({
+              page: parseInt(pM[1]),
+              x: parseFloat(xM[1]),
+              y: parseFloat(yM[1]),
+              width: parseFloat(wM[1]),
+              height: parseFloat(hM[1])
+            });
+          }
+        }
+        if (pageBBoxes.length > 0) citation.pages = pageBBoxes;
+      }
+    } else {
+      citation.page = parseInt(pageStr, 10) || 0;
+      const bboxMatch = rest.match(/bbox:\s*\{([^}]+)\}/);
+      if (bboxMatch) {
+        const bboxStr = bboxMatch[1];
+        const xM = bboxStr.match(/x:\s*([\d.]+)/);
+        const yM = bboxStr.match(/y:\s*([\d.]+)/);
+        const wM = bboxStr.match(/width:\s*([\d.]+)/);
+        const hM = bboxStr.match(/height:\s*([\d.]+)/);
+        if (xM && yM && wM && hM) {
+          citation.bbox = {
+            x: parseFloat(xM[1]),
+            y: parseFloat(yM[1]),
+            width: parseFloat(wM[1]),
+            height: parseFloat(hM[1])
+          };
+        }
+      }
+    }
+    citations.push(citation);
+  }
+  return { answer, citations };
+}
+var Y_TOLERANCE = 3;
+var X_GAP_COLUMN = 15;
+function buildTextRun(textItems) {
+  if (textItems.length === 0) return { text: "", segments: [] };
+  const items = textItems.filter((t) => t.text.trim().length > 0);
+  if (items.length === 0) return { text: "", segments: [] };
+  const sorted = [...items].sort((a, b) => {
+    const dy = a.y - b.y;
+    if (Math.abs(dy) > Y_TOLERANCE) return dy;
+    return a.x - b.x;
+  });
+  const lines = [];
+  let currentLine = [sorted[0]];
+  let currentY = sorted[0].y;
+  for (let i = 1; i < sorted.length; i++) {
+    if (Math.abs(sorted[i].y - currentY) <= Y_TOLERANCE) {
+      currentLine.push(sorted[i]);
+    } else {
+      lines.push(currentLine);
+      currentLine = [sorted[i]];
+      currentY = sorted[i].y;
+    }
+  }
+  lines.push(currentLine);
+  for (const line of lines) {
+    line.sort((a, b) => a.x - b.x);
+  }
+  let text = "";
+  const segments = [];
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li];
+    for (let ii = 0; ii < line.length; ii++) {
+      const item = line[ii];
+      if (ii > 0) {
+        const prev = line[ii - 1];
+        const gap = item.x - (prev.x + prev.width);
+        if (gap > X_GAP_COLUMN) {
+          text += "  ";
+        } else if (gap >= 0) {
+          text += " ";
+        }
+      }
+      const start = text.length;
+      text += item.text;
+      const end = text.length;
+      segments.push({
+        start,
+        end,
+        bbox: { x: item.x, y: item.y, width: item.width, height: item.height }
+      });
+    }
+    if (li < lines.length - 1) {
+      text += "\n";
+    }
+  }
+  return { text, segments };
+}
+function normalize(s) {
+  return s.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function findSubstring(haystack, needle) {
+  const idx = haystack.indexOf(needle);
+  if (idx >= 0) return [idx, idx + needle.length];
+  return null;
+}
+function findNormalized(haystack, needle) {
+  const normHay = normalize(haystack);
+  const normNeedle = normalize(needle);
+  if (!normNeedle) return null;
+  const idx = normHay.indexOf(normNeedle);
+  if (idx < 0) return null;
+  let normPos = 0;
+  let origStart = -1;
+  let origEnd = -1;
+  for (let i = 0; i < haystack.length && origEnd < 0; i++) {
+    const normChar = normalize(haystack[i]);
+    if (normChar.length === 0) continue;
+    if (/\s/.test(haystack[i])) {
+      let j = i;
+      while (j < haystack.length && /\s/.test(haystack[j])) j++;
+      if (normPos === idx) origStart = i;
+      normPos++;
+      if (normPos >= idx + normNeedle.length && origEnd < 0) origEnd = j;
+      i = j - 1;
+      continue;
+    }
+    if (normPos === idx) origStart = i;
+    normPos++;
+    if (normPos >= idx + normNeedle.length && origEnd < 0) origEnd = i + 1;
+  }
+  if (origStart >= 0 && origEnd > origStart) return [origStart, origEnd];
+  return null;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function findFuzzy(haystack, needle, maxDistRatio = 0.2) {
+  const normHay = normalize(haystack);
+  const normNeedle = normalize(needle);
+  if (!normNeedle || normNeedle.length < 5) return null;
+  const baseSize = normNeedle.length;
+  const maxDist = Math.ceil(baseSize * maxDistRatio);
+  let bestDist = maxDist + 1;
+  let bestIdx = -1;
+  let bestWinSize = baseSize;
+  const minWin = Math.max(5, baseSize - maxDist);
+  const maxWin = baseSize + maxDist;
+  for (let winSize = minWin; winSize <= maxWin; winSize++) {
+    if (winSize > normHay.length) break;
+    for (let i = 0; i <= normHay.length - winSize; i++) {
+      const window = normHay.substring(i, i + winSize);
+      const dist = levenshtein(window, normNeedle);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIdx = i;
+        bestWinSize = winSize;
+        if (dist === 0) break;
+      }
+    }
+    if (bestDist === 0) break;
+  }
+  if (bestIdx < 0 || bestDist > maxDist) return null;
+  let normPos = 0;
+  let origStart = 0;
+  let origEnd = haystack.length;
+  for (let i = 0; i < haystack.length; i++) {
+    const ch = haystack[i];
+    if (/\s/.test(ch)) {
+      let j = i;
+      while (j < haystack.length && /\s/.test(haystack[j])) j++;
+      if (normPos === bestIdx) origStart = i;
+      normPos++;
+      if (normPos >= bestIdx + bestWinSize) {
+        origEnd = j;
+        break;
+      }
+      i = j - 1;
+      continue;
+    }
+    if (/[^\w\s]/.test(ch)) continue;
+    if (normPos === bestIdx) origStart = i;
+    normPos++;
+    if (normPos >= bestIdx + bestWinSize) {
+      origEnd = i + 1;
+      break;
+    }
+  }
+  const confidence = 1 - bestDist / baseSize;
+  return [origStart, origEnd, confidence];
+}
+function getBoxesForRange(segments, start, end) {
+  const boxes = [];
+  for (const seg of segments) {
+    if (seg.end > start && seg.start < end) {
+      boxes.push(seg.bbox);
+    }
+  }
+  return boxes;
+}
+function mergeBoxes(boxes) {
+  if (boxes.length === 0) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const b of boxes) {
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    if (b.x + b.width > maxX) maxX = b.x + b.width;
+    if (b.y + b.height > maxY) maxY = b.y + b.height;
+  }
+  return {
+    x: Math.round(minX * 100) / 100,
+    y: Math.round(minY * 100) / 100,
+    width: Math.round((maxX - minX) * 100) / 100,
+    height: Math.round((maxY - minY) * 100) / 100
+  };
+}
+function normalizeFilename(name) {
+  return name.replace(/\.(md|json|pdf)$/i, "").replace(/^\d+\.\s*/, "").toLowerCase().trim();
+}
+async function resolveJsonPath(file, sourcesDir) {
+  const withExt = file.endsWith(".md") ? file : file + ".md";
+  const exact = join2(sourcesDir, withExt.replace(/\.md$/, ".json"));
+  if (existsSync2(exact)) return exact;
+  try {
+    const files = await readdir2(sourcesDir);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    const needle = normalizeFilename(file);
+    for (const jf of jsonFiles) {
+      if (normalizeFilename(jf) === needle) return join2(sourcesDir, jf);
+    }
+    for (const jf of jsonFiles) {
+      const candidate = normalizeFilename(jf);
+      if (candidate.includes(needle) || needle.includes(candidate)) {
+        return join2(sourcesDir, jf);
+      }
+    }
+    const needleWords = needle.split(/\s+/);
+    let bestScore = 0;
+    let bestFile = null;
+    for (const jf of jsonFiles) {
+      const candidateWords = normalizeFilename(jf).split(/\s+/);
+      const matches = needleWords.filter((w) => candidateWords.some((c) => c.includes(w) || w.includes(c)));
+      const score = matches.length / Math.max(needleWords.length, 1);
+      if (score > bestScore && score >= 0.6) {
+        bestScore = score;
+        bestFile = jf;
+      }
+    }
+    if (bestFile) return join2(sourcesDir, bestFile);
+  } catch {
+  }
+  return null;
+}
+async function matchCitation(citation, sourcesDir, options) {
+  const base = {
+    ...citation,
+    matched: false,
+    confidence: 0,
+    boundingBoxes: [],
+    mergedRect: null
+  };
+  const jsonPath = await resolveJsonPath(citation.file, sourcesDir);
+  if (!jsonPath) return base;
+  let bboxData;
+  try {
+    bboxData = JSON.parse(await readFile2(jsonPath, "utf-8"));
+  } catch {
+    return base;
+  }
+  const pagesToTry = [];
+  if (citation.page && citation.page > 0) {
+    const page = bboxData.pages?.find((p) => p.page === citation.page);
+    if (page) pagesToTry.push(page);
+    const prev = bboxData.pages?.find((p) => p.page === citation.page - 1);
+    const next = bboxData.pages?.find((p) => p.page === citation.page + 1);
+    if (prev) pagesToTry.push(prev);
+    if (next) pagesToTry.push(next);
+  } else {
+    pagesToTry.push(...bboxData.pages ?? []);
+  }
+  if (pagesToTry.length === 0) return base;
+  let bestMatch = null;
+  for (const page of pagesToTry) {
+    const textItems = (page.textItems ?? []).map((t) => ({
+      text: t.text ?? "",
+      x: t.x ?? 0,
+      y: t.y ?? 0,
+      width: t.width ?? 0,
+      height: t.height ?? 0
+    }));
+    const run = buildTextRun(textItems);
+    if (!run.text) continue;
+    const exact = findSubstring(run.text, citation.quote);
+    if (exact) {
+      const boxes = getBoxesForRange(run.segments, exact[0], exact[1]);
+      const result = {
+        ...citation,
+        page: page.page,
+        matched: true,
+        confidence: 1,
+        boundingBoxes: boxes,
+        mergedRect: mergeBoxes(boxes)
+      };
+      return result;
+    }
+    const norm = findNormalized(run.text, citation.quote);
+    if (norm) {
+      const boxes = getBoxesForRange(run.segments, norm[0], norm[1]);
+      const result = {
+        ...citation,
+        page: page.page,
+        matched: true,
+        confidence: 0.9,
+        boundingBoxes: boxes,
+        mergedRect: mergeBoxes(boxes)
+      };
+      if (!bestMatch || result.confidence > bestMatch.confidence) bestMatch = result;
+      continue;
+    }
+    if (options?.skipFuzzy) continue;
+    const fuzzy = findFuzzy(run.text, citation.quote);
+    if (fuzzy) {
+      const [start, end, confidence] = fuzzy;
+      const boxes = getBoxesForRange(run.segments, start, end);
+      const result = {
+        ...citation,
+        page: page.page,
+        matched: confidence >= 0.5,
+        confidence,
+        boundingBoxes: boxes,
+        mergedRect: mergeBoxes(boxes)
+      };
+      if (!bestMatch || result.confidence > bestMatch.confidence) bestMatch = result;
+    }
+  }
+  return bestMatch ?? base;
+}
+
+// src/wiki-updater.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/complete-with-fallback.ts
+function getErrorMessage2(error) {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "Unknown error");
+}
+function isRetryableProviderError2(error) {
+  const message = getErrorMessage2(error).toLowerCase();
+  return [
+    "401",
+    "403",
+    "429",
+    "quota",
+    "credit",
+    "rate limit",
+    "overloaded",
+    "overload",
+    "unavailable",
+    "timeout",
+    "timed out",
+    "network",
+    "connection",
+    "provider",
+    "api key",
+    "authentication",
+    "unauthorized",
+    "forbidden"
+  ].some((term) => message.includes(term));
+}
+async function completeWithFallback(modelId, authStorage, purpose, input) {
+  const candidates = await resolveModelCandidates(modelId, authStorage, purpose);
+  if (candidates.length === 0) {
+    throw new Error(`No usable model found for '${modelId}'. Configure Anthropic, OpenRouter, or OpenAI credentials.`);
+  }
+  let lastError;
+  for (let i = 0; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    const apiKey = await getApiKeyForProvider(candidate.provider, authStorage);
+    if (!apiKey) continue;
+    try {
+      return await completeSimple(candidate.model, input, { apiKey });
+    } catch (error) {
+      lastError = error;
+      if (i === candidates.length - 1 || !isRetryableProviderError2(error)) throw error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(getErrorMessage2(lastError));
+}
+
+// src/wiki-updater.ts
+function formatCitationsForWiki(citations) {
+  if (citations.length === 0) return "";
+  const lines = citations.map(
+    (c, i) => `  [${i + 1}] ${c.file}, p.${c.page}: "${c.quote}"`
+  );
+  return `
+
+**Verified citations (preserve page numbers in wiki):**
+${lines.join("\n")}`;
+}
+function buildPrompt(question, answer, sources, date, currentWiki, citations) {
+  const citationsSection = citations && citations.length > 0 ? formatCitationsForWiki(citations) : "";
+  const rules = `Rules for wiki structure:
+- Use ## for CONCEPTS and TOPICS \u2014 NOT source file names
+  Good: "## Electronic Evidence", "## Mob Lynching", "## Burden of Proof"
+  Bad: "## Indian Evidence Act.md", "## indian penal code - new.md"
+- Use ### for subtopics within a concept
+- A concept can draw from MULTIPLE source files \u2014 synthesize, don't separate by file
+- If knowledge from this Q&A fits an existing concept, ADD to it \u2014 never duplicate
+- If it's a genuinely new concept, create a new ## section
+- Be concise: bullet points for lists, short prose for explanations
+- ALWAYS include source citations with page numbers inline: (Source: filename, p.X)
+- Every factual claim must have a page-level citation \u2014 this is critical for verification
+- Add cross-references where concepts relate: See also: [[Other Concept]]
+- End each ## section with: *Sources: file1, file2 \xB7 date*
+- Separate ## sections with: ---`;
+  if (currentWiki.trim()) {
+    return `You are maintaining a concept-organized knowledge wiki.
+
+## Current wiki
+${currentWiki}
+
+## New Q&A to integrate
+**Question:** ${question}
+**Sources used:** ${sources}
+**Date:** ${date}
+
+**Answer:**
+${answer}${citationsSection}
+
+---
+
+Update the wiki to integrate this new knowledge.
+${rules}
+
+Return ONLY the complete updated wiki markdown. No explanation.`;
+  }
+  return `You are creating a concept-organized knowledge wiki.
+
+## First Q&A to add
+**Question:** ${question}
+**Sources used:** ${sources}
+**Date:** ${date}
+
+**Answer:**
+${answer}${citationsSection}
+
+---
+
+Create a clean wiki from this Q&A.
+- Start with: # Knowledge Wiki\\n\\n> Concept-organized knowledge base. Updated after each query.\\n\\n---
+${rules}
+
+Return ONLY the wiki markdown. No explanation.`;
+}
+async function updateWiki(kbRoot, trace, authStorage, indexModelId = "claude-haiku-4-5") {
+  if (trace.mode !== "query" || !trace.question || !trace.answer) return;
+  const wikiDir = join3(kbRoot, ".llm-kb", "wiki");
+  await mkdir2(wikiDir, { recursive: true });
+  const wikiPath = join3(wikiDir, "wiki.md");
+  const currentWiki = existsSync3(wikiPath) ? await readFile3(wikiPath, "utf-8").catch(() => "") : "";
+  const sources = trace.filesRead.map((f) => f.split(/[\\/]/).pop() ?? f).filter((f) => f.endsWith(".md") && f !== "index.md" && f !== "wiki.md").join(", ") || "unknown";
+  const date = new Date(trace.timestamp).toISOString().slice(0, 10);
+  const answer = trace.answerWithoutCitations ?? trace.answer;
+  const prompt = buildPrompt(trace.question, answer, sources, date, currentWiki, trace.citations);
+  const result = await completeWithFallback(
+    indexModelId,
+    authStorage,
+    "wiki",
+    {
+      systemPrompt: "You are a precise knowledge librarian. Organize information by CONCEPT, not by source file. Synthesize knowledge from multiple sources into unified topic articles. ALWAYS preserve page-level citations (Source: filename, p.X) for every fact. Return only clean markdown.",
+      messages: [{ role: "user", content: prompt, timestamp: Date.now() }]
+    }
+  );
+  const text = result.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+  if (text) {
+    await writeFile2(wikiPath, text + "\n", "utf-8");
+  }
+}
+
+// src/query.ts
+import { join as join4, basename } from "path";
+import chalk2 from "chalk";
+
+// src/md-stream.ts
+import chalk from "chalk";
+var MarkdownStream = class {
+  buffer = "";
+  isTTY;
+  constructor(isTTY = false) {
+    this.isTTY = isTTY;
+  }
+  /** Feed a text_delta chunk. Returns styled string ready for stdout. */
+  push(chunk) {
+    if (!this.isTTY) return chunk;
+    this.buffer += chunk;
+    return this.drain(false);
+  }
+  /** Flush remaining buffer (call on text_end). */
+  end() {
+    if (!this.isTTY) return "";
+    const out = this.drain(true);
+    this.buffer = "";
+    return out;
+  }
+  drain(final) {
+    let out = "";
+    while (true) {
+      const nlIdx = this.buffer.indexOf("\n");
+      if (nlIdx === -1) {
+        if (final && this.buffer.length > 0) {
+          out += this.renderLine(this.buffer);
+          this.buffer = "";
+        }
+        break;
+      }
+      const line = this.buffer.slice(0, nlIdx);
+      this.buffer = this.buffer.slice(nlIdx + 1);
+      out += this.renderLine(line) + "\n";
+    }
+    return out;
+  }
+  /** Render a single complete line with block + inline styling. */
+  renderLine(line) {
+    const trimmed = line.trimStart();
+    if (/^-{3,}\s*$/.test(trimmed) || /^\*{3,}\s*$/.test(trimmed)) {
+      const cols = process.stdout.columns || 80;
+      return chalk.dim("\u2500".repeat(Math.min(cols, 60)));
+    }
+    const headerMatch = trimmed.match(/^(#{1,6})\s+(.*)$/);
+    if (headerMatch) {
+      const text = this.inline(headerMatch[2]);
+      return "\n" + chalk.bold(text);
+    }
+    const bulletMatch = trimmed.match(/^[-*+]\s+(.*)$/);
+    if (bulletMatch) {
+      const indent = line.length - trimmed.length;
+      return " ".repeat(indent) + chalk.dim("\u2022") + " " + this.inline(bulletMatch[1]);
+    }
+    const numMatch = trimmed.match(/^(\d+)[.)]\s+(.*)$/);
+    if (numMatch) {
+      const indent = line.length - trimmed.length;
+      return " ".repeat(indent) + chalk.dim(numMatch[1] + ".") + " " + this.inline(numMatch[2]);
+    }
+    if (/^\|[\s\-:|]+\|$/.test(trimmed)) {
+      return chalk.dim(trimmed);
+    }
+    if (trimmed.startsWith("|") && trimmed.endsWith("|")) {
+      return this.inline(line);
+    }
+    if (trimmed.startsWith(">")) {
+      const content = trimmed.replace(/^>+\s*/, "");
+      return chalk.dim("\u2502 ") + chalk.italic(this.inline(content));
+    }
+    return this.inline(line);
+  }
+  /** Apply inline markdown styling to text. */
+  inline(text) {
+    text = text.replace(/`([^`]+)`/g, (_, c) => chalk.cyan(c));
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => chalk.bold.italic(t));
+    text = text.replace(/\*\*(.+?)\*\*/g, (_, t) => chalk.bold(t));
+    text = text.replace(/(?<!\*)\*(.+?)\*(?!\*)/g, (_, t) => chalk.italic(t));
+    text = text.replace(/~~(.+?)~~/g, (_, t) => chalk.strikethrough(t));
+    text = text.replace(
+      /\[([^\]]+)\]\(([^)]+)\)/g,
+      (_, label, url) => `${label} ${chalk.dim(`(${url})`)}`
+    );
+    return text;
+  }
+};
+
+// src/query.ts
+function extractAnswerText(content) {
+  return (content ?? []).filter((b) => b.type === "text").map((b) => b.text ?? "").join("").trim();
+}
+function extractFilesRead(messages) {
+  const paths = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const block of msg.content ?? []) {
+      if (block.type === "toolCall" && block.name === "read") {
+        const p = block.arguments?.path ?? "";
+        if (p && !paths.includes(p)) paths.push(p);
+      }
+    }
+  }
+  return paths;
+}
+function validateQueryResult(session, beforeMessageCount) {
+  const messages = Array.isArray(session.state?.messages) ? session.state.messages.slice(beforeMessageCount) : [];
+  const assistant = [...messages].reverse().find((m) => m.role === "assistant");
+  if (!assistant) return "no assistant response produced";
+  const text = extractAnswerText(assistant.content ?? []);
+  if (!text.trim()) return "assistant response was empty";
+  return void 0;
+}
+function getToolLabel(toolName, args) {
+  if (toolName === "read" || toolName === "write" || toolName === "edit") {
+    const file = basename(args?.path ?? "");
+    if (!file || !/\.[a-z0-9]{1,6}$/i.test(file)) return null;
+    const verb = toolName === "read" ? "Reading" : toolName === "write" ? "Writing" : "Editing";
+    return `${verb}  ${file}`;
+  }
+  if (toolName === "bash" && args?.command) {
+    return `Running  bash`;
+  }
+  return null;
+}
+function buildQueryAgents(sourceFiles, save, wikiContent) {
+  const sourceList = sourceFiles.map((f) => `  - ${f}`).join("\n");
+  const wikiSection = wikiContent ? `## Knowledge Wiki (use this first)
+
+The wiki below contains knowledge already extracted from this knowledge base.
+If the user's question is covered here, answer directly from it \u2014 no need to re-read source files.
+Always cite the original source files mentioned in the wiki.
+
+${wikiContent}
+
+---
+
+` : "";
+  const sourceStep = wikiContent ? "If not covered in the wiki above: read the sources" : "How to answer";
+  const lines = [
+    `# llm-kb Knowledge Base \u2014 Query Mode`,
+    ``,
+    `## MANDATORY: Citation Format`,
+    `Every answer MUST end with a CITATIONS block. No exceptions. Not optional. Even for simple or wiki-sourced answers.`,
+    `If you do not include a CITATIONS block, the answer is considered INVALID.`,
+    ``,
+    `You MUST place [1], [2], etc. inline in your answer text next to every claim or fact.`,
+    `Example: "Revenue grew 12% [1] driven by gaming segment expansion [2]."`,
+    `Every factual statement needs an inline citation number. Then ALWAYS end with:`,
+    ``,
+    `CITATIONS:`,
+    `[1] file: "document.pdf", page: 3, quote: "exact text from source"`,
+    `[2] file: "other.pdf", page: 7, quote: "another exact excerpt"`,
+    ``,
+    `Rules:`,
+    `- Use the ORIGINAL PDF filename (e.g. "report.pdf", not the .md version)`,
+    `- Quote must be an exact excerpt from the source text`,
+    `- Include the correct page number`,
+    `- Bounding boxes are optional but improve the experience. If you include them, use this format:`,
+    `  [1] file: "document.pdf", page: 3, quote: "exact text", bbox: {x: 142, y: 340, width: 234, height: 14}`,
+    `- To get bboxes, use a single bash script AFTER writing the full answer:`,
+    "```",
+    `node -e "`,
+    `  const fs = require('fs');`,
+    `  const d = JSON.parse(fs.readFileSync('.llm-kb/wiki/sources/FILE.json','utf8'));`,
+    `  const p = d.pages.find(p=>p.page===PAGE);`,
+    `  const items = p.textItems.filter(t=>t.text.includes('KEYWORD'));`,
+    `  console.log('source:', d.source, 'bbox:', JSON.stringify(items.map(t=>({x:t.x,y:t.y,w:t.width,h:t.height}))));`,
+    `"`,
+    "```",
+    `- If answering from wiki, cite the original source files mentioned in the wiki entries`,
+    ``,
+    wikiSection,
+    `## ${sourceStep}`,
+    ``,
+    `1. Read .llm-kb/wiki/index.md to understand all available sources`,
+    `2. Select the most relevant source files (usually 2-5) and read them in full`,
+    `3. Answer the question with [1], [2] inline references`,
+    `4. If you can't find the answer, say so \u2014 don't hallucinate`,
+    `5. ALWAYS end with a CITATIONS block (see top of this file)`,
+    ``,
+    `## Available parsed sources`,
+    sourceList,
+    ``,
+    `## Non-PDF files (docx, xlsx, pptx)`,
+    `Use bash to run Node.js scripts. Libraries are pre-installed via require().`,
+    ``,
+    `### Word (.docx) \u2014 structured XML`,
+    `.docx files are ZIP archives containing word/document.xml.`,
+    `Read them SELECTIVELY \u2014 extract only what is relevant to the question:`,
+    ``,
+    "```javascript",
+    `const AdmZip = require('adm-zip');`,
+    `const zip = new AdmZip('file.docx');`,
+    `const xml = zip.readAsText('word/document.xml');`,
+    `// Parse XML to find specific paragraphs, headings, tables`,
+    "```",
+    ``,
+    `Strategy for large .docx files:`,
+    `1. First: extract headings/structure to understand the document layout`,
+    `2. Then: extract only the sections relevant to the user's question`,
+    `NEVER dump the entire document.`,
+    ``,
+    `### Excel (.xlsx) \u2014 use exceljs`,
+    `Read specific sheets and ranges, not the whole workbook:`,
+    ``,
+    "```javascript",
+    `const ExcelJS = require('exceljs');`,
+    `const wb = new ExcelJS.Workbook();`,
+    `await wb.xlsx.readFile('file.xlsx');`,
+    `const sheet = wb.getWorksheet(1);`,
+    `// Read specific rows/columns relevant to the question`,
+    "```",
+    ``,
+    `### PowerPoint (.pptx) \u2014 use officeparser`,
+    ``,
+    "```javascript",
+    `const officeparser = require('officeparser');`,
+    `const text = await officeparser.parseOfficeAsync('file.pptx');`,
+    "```",
+    ``,
+    `## Rules`,
+    `- Always cite sources with filename and page number`,
+    `- Read the FULL source file, not just the beginning (for .md sources)`,
+    `- For non-PDF files, extract ONLY relevant sections \u2014 never dump entire files`,
+    `- Prefer primary sources over previous analyses`,
+    ``,
+    `## Guidelines`,
+    `A guidelines file may exist at .llm-kb/guidelines.md with learned rules from`,
+    `past evaluations and user preferences. Read it when:`,
+    `- You're unsure about citation accuracy or format`,
+    `- You're about to read source files (guidelines may suggest using wiki instead)`,
+    `- The question touches a topic that may have had issues in past evaluations`
+  ];
+  if (save) {
+    lines.push(``, `## Research Mode`, `Save your analysis to .llm-kb/wiki/outputs/ with a descriptive filename.`, `Include the question at the top and all citations.`);
+  }
+  return lines.join("\n");
+}
+var WikiUpdateScheduler = class {
+  constructor(everyN, everyMin) {
+    this.everyN = everyN;
+    this.everyMin = everyMin;
+  }
+  everyN;
+  everyMin;
+  stopMsgCount = 0;
+  lastUpdateAt = 0;
+  chain = Promise.resolve();
+  shouldUpdate() {
+    return this.stopMsgCount > 0 && this.stopMsgCount % this.everyN === 0 || this.lastUpdateAt > 0 && Date.now() - this.lastUpdateAt > this.everyMin * 6e4;
+  }
+  enqueue(work) {
+    this.chain = this.chain.then(() => work().catch(() => {
+    }));
+  }
+  onMessageEnd(msg, snap, doUpdate) {
+    if (msg.role !== "assistant" || msg.stopReason !== "stop") return;
+    this.stopMsgCount++;
+    if (this.shouldUpdate()) {
+      this.lastUpdateAt = Date.now();
+      this.enqueue(() => doUpdate(snap().messages));
+    }
+  }
+  onAgentEnd(msgs, doUpdate) {
+    this.lastUpdateAt = Date.now();
+    this.enqueue(() => doUpdate(msgs));
+  }
+  flush() {
+    return this.chain;
+  }
+};
+function subscribeDisplay(session, opts) {
+  const ui = opts.tuiDisplay;
+  const dim = (s) => process.stdout.isTTY ? chalk2.dim(s) : s;
+  const thinLine = () => dim("\u2500".repeat(process.stdout.columns || 80));
+  let phase = "idle";
+  let filesReadCount = 0;
+  let shownToolCalls = /* @__PURE__ */ new Set();
+  let startTime = Date.now();
+  let md = new MarkdownStream(process.stdout.isTTY ?? false);
+  let lastQuestion = "";
+  const scheduler = new WikiUpdateScheduler(5, 3);
+  const sourcesDir = join4(opts.folder, ".llm-kb", "wiki", "sources");
+  const verifyCitations = async (citations) => {
+    if (citations.length === 0) return citations;
+    try {
+      const verified = await Promise.all(
+        citations.map((c) => matchCitation(c, sourcesDir))
+      );
+      return verified.map((m) => {
+        if (m.mergedRect) {
+          return { file: m.file, page: m.page, quote: m.quote, bbox: m.mergedRect, pages: m.pages };
+        }
+        return { file: m.file, page: m.page, quote: m.quote, bbox: m.bbox, pages: m.pages };
+      });
+    } catch {
+      return citations;
+    }
+  };
+  const buildTrace2 = (messages) => {
+    const last = [...messages].reverse().find((m) => m.role === "assistant" && m.stopReason === "stop");
+    if (!last) return null;
+    const filesRead = extractFilesRead(messages);
+    const fullAnswer = extractAnswerText(last.content);
+    const parsed = parseCitations(fullAnswer);
+    return {
+      sessionId: session.sessionId,
+      sessionFile: session.sessionFile ?? "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: "query",
+      question: lastQuestion,
+      answer: fullAnswer,
+      answerWithoutCitations: parsed.answer,
+      citations: parsed.citations.length > 0 ? parsed.citations : void 0,
+      filesRead,
+      filesAvailable: opts.mdFiles,
+      filesSkipped: opts.mdFiles.filter((f) => !filesRead.some((r) => r.endsWith(f))),
+      model: last.model
+    };
+  };
+  const doUpdate = async (messages) => {
+    const trace = buildTrace2(messages);
+    if (!trace) return;
+    if (trace.citations && trace.citations.length > 0) {
+      trace.citations = await verifyCitations(trace.citations);
+    }
+    await saveTrace(opts.folder, trace);
+    await appendToQueryLog(opts.folder, trace);
+    await updateWiki(opts.folder, trace, opts.authStorage);
+  };
+  session.subscribe((event) => {
+    if (event.type === "agent_start") {
+      phase = "idle";
+      filesReadCount = 0;
+      shownToolCalls = /* @__PURE__ */ new Set();
+      startTime = Date.now();
+      md = new MarkdownStream(process.stdout.isTTY ?? false);
+      const modelName = opts.modelId ?? "claude-sonnet-4-6";
+      if (ui) {
+        ui.disableInput();
+        ui.beginResponse(modelName);
+      } else process.stdout.write(dim(`\u27E1 ${modelName}`) + "\n");
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "thinking_start") {
+        if (!ui) process.stdout.write(dim("\n\u25B8 Thinking\n"));
+        phase = "thinking";
+      }
+      if (ae.type === "thinking_delta") {
+        if (ui) ui.appendThinking(ae.delta);
+        else process.stdout.write(dim(`  ${ae.delta}`));
+      }
+      if (ae.type === "thinking_end") {
+        if (ui) ui.endThinking();
+        else process.stdout.write("\n");
+      }
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "toolcall_end" && ae.toolCall) {
+        const label = getToolLabel(ae.toolCall.name, ae.toolCall.arguments);
+        if (label) {
+          if (!ui && phase !== "tools") process.stdout.write("\n");
+          phase = "tools";
+          if (ui) {
+            ui.addToolCall(ae.toolCall.id, label, ae.toolCall.name);
+            if (ae.toolCall.name === "bash" && ae.toolCall.arguments?.command) {
+              ui.addCodeBlock(ae.toolCall.arguments.command);
+            }
+          } else {
+            process.stdout.write(dim(`  \u25B8 ${label}`) + "\n");
+            if (ae.toolCall.name === "bash" && ae.toolCall.arguments?.command) {
+              const code = ae.toolCall.arguments.command;
+              process.stdout.write(dim(code.split("\n").map((l) => `    ${l}`).join("\n")) + "\n");
+            }
+            shownToolCalls.add(ae.toolCall.id);
+            if (ae.toolCall.name === "read") filesReadCount++;
+          }
+        }
+      }
+    }
+    if (event.type === "tool_execution_start") {
+      const { toolCallId, toolName, args } = event;
+      if (ui) {
+        const label = getToolLabel(toolName, args);
+        if (label) ui.addToolCall(toolCallId, label, toolName);
+      } else if (!shownToolCalls.has(toolCallId)) {
+        const label = getToolLabel(toolName, args);
+        if (label) {
+          if (phase !== "tools") process.stdout.write("\n");
+          phase = "tools";
+          process.stdout.write(dim(`  \u25B8 ${label}`) + "\n");
+          shownToolCalls.add(toolCallId);
+          if (toolName === "read") filesReadCount++;
+        }
+      }
+    }
+    if (event.type === "tool_execution_end") {
+      const { toolCallId, isError } = event;
+      if (ui) ui.addToolResult(toolCallId, isError);
+    }
+    if (event.type === "message_update") {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === "text_start" && phase !== "answer") {
+        if (ui) ui.beginAnswer();
+        else if (phase === "thinking" || phase === "tools") {
+          process.stdout.write(`
+${thinLine()}
+
+`);
+        }
+        phase = "answer";
+      }
+      if (ae.type === "text_delta") {
+        if (ui) ui.appendAnswer(ae.delta);
+        else process.stdout.write(md.push(ae.delta));
+      }
+      if (ae.type === "text_end" && !ui) process.stdout.write(md.end());
+    }
+    if (event.type === "agent_end") {
+      const trace = buildTrace2(event.messages);
+      const rawCitations = trace?.citations ?? [];
+      verifyCitations(rawCitations).then((citations) => {
+        if (trace && citations.length > 0) trace.citations = citations;
+        if (ui) {
+          ui.showCompletion(citations);
+          ui.enableInput();
+        } else {
+          if (citations.length > 0) {
+            process.stdout.write(`
+${dim("\u2500\u2500 Citations " + "\u2500".repeat(Math.max(0, (process.stdout.columns || 80) - 14)))}
+`);
+            for (let i = 0; i < citations.length; i++) {
+              const c = citations[i];
+              const pageStr = c.pages && c.pages.length > 0 ? `p.${c.pages.map((p) => p.page).join("-")}` : `p.${c.page}`;
+              const hasBbox = c.bbox || c.pages && c.pages.length > 0;
+              let bboxDetail;
+              if (c.pages && c.pages.length > 0) {
+                bboxDetail = `\u2705 bbox (${c.pages.length} pages)`;
+              } else if (c.bbox) {
+                bboxDetail = `\u2705 bbox (${c.bbox.x},${c.bbox.y} \u2192 ${Math.round(c.bbox.x + c.bbox.width)},${Math.round(c.bbox.y + c.bbox.height)})`;
+              } else {
+                bboxDetail = `\u26A0\uFE0F  no bbox`;
+              }
+              const quote = c.quote.length > 60 ? c.quote.slice(0, 57) + "..." : c.quote;
+              process.stdout.write(`
+  ${chalk2.bold(`[${i + 1}]`)} \u{1F4C4} ${c.file}, ${pageStr}
+`);
+              process.stdout.write(dim(`      "${quote}"`) + "\n");
+              process.stdout.write(`      ${bboxDetail}
+`);
+            }
+          }
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          const source = filesReadCount > 0 ? `${filesReadCount} file${filesReadCount !== 1 ? "s" : ""} read` : "wiki";
+          const citCount = citations.length > 0 ? ` \xB7 ${citations.length} citation${citations.length !== 1 ? "s" : ""}` : "";
+          const stats = `${elapsed}s \xB7 ${source}${citCount}`;
+          const cols = process.stdout.columns || 80;
+          const pad = Math.max(0, cols - stats.length - 4);
+          process.stdout.write(`
+${dim("\u2500\u2500 " + stats + " " + "\u2500".repeat(pad))}
+`);
+        }
+      });
+      scheduler.onAgentEnd(event.messages, doUpdate);
+    }
+    if (event.type === "message_end") {
+      scheduler.onMessageEnd(event.message, () => ({ messages: session.state.messages }), doUpdate);
+    }
+  });
+  return {
+    setQuestion(q) {
+      lastQuestion = q;
+    },
+    flush() {
+      return scheduler.flush();
+    }
+  };
+}
+async function createChat(folder, options) {
+  const sourcesDir = join4(folder, ".llm-kb", "wiki", "sources");
+  const files = await readdir3(sourcesDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) throw new Error("No sources found. Run 'llm-kb run' first.");
+  if (options.save) await mkdir3(join4(folder, ".llm-kb", "wiki", "outputs"), { recursive: true });
+  process.env.NODE_PATH = getNodeModulesPath();
+  const wikiPath = join4(folder, ".llm-kb", "wiki", "wiki.md");
+  const save = !!options.save;
+  const loader = new DefaultResourceLoader({
+    cwd: folder,
+    agentsFilesOverride: (current) => {
+      const currentFiles = readdirSync(sourcesDir).filter((f) => f.endsWith(".md"));
+      const wiki = existsSync4(wikiPath) ? readFileSync(wikiPath, "utf-8") : "";
+      const content = buildQueryAgents(currentFiles, save, wiki);
+      return {
+        agentsFiles: [...current.agentsFiles, { path: ".llm-kb/AGENTS.md", content }]
+      };
+    }
+  });
+  await loader.reload();
+  const tools = [
+    createReadTool(folder),
+    createBashTool(folder),
+    createWriteTool(folder)
+  ];
+  const candidates = options.modelId ? await resolveModelCandidates(options.modelId, options.authStorage, "query") : [];
+  if (options.modelId && candidates.length === 0) {
+    throw new Error(`No usable model found for '${options.modelId}'. Configure Anthropic, OpenRouter, or OpenAI credentials.`);
+  }
+  const session = options.modelId ? await createRetryingSession({
+    candidates,
+    validatePromptResult: validateQueryResult,
+    createSession: async (candidate) => {
+      const { session: session2 } = await createAgentSession({
+        cwd: folder,
+        resourceLoader: loader,
+        tools,
+        sessionManager: options.save ? await createKBSession(folder) : await continueKBSession(folder),
+        settingsManager: SettingsManager.inMemory({ compaction: { enabled: false } }),
+        thinkingLevel: "low",
+        ...options.authStorage ? { authStorage: options.authStorage } : {},
+        model: candidate.model
+      });
+      return session2;
+    }
+  }) : (await createAgentSession({
+    cwd: folder,
+    resourceLoader: loader,
+    tools,
+    sessionManager: options.save ? await createKBSession(folder) : await continueKBSession(folder),
+    settingsManager: SettingsManager.inMemory({ compaction: { enabled: false } }),
+    thinkingLevel: "low",
+    ...options.authStorage ? { authStorage: options.authStorage } : {}
+  })).session;
+  const display = subscribeDisplay(session, {
+    modelId: options.modelId,
+    authStorage: options.authStorage,
+    folder,
+    mdFiles,
+    tuiDisplay: options.tuiDisplay
+  });
+  async function reloadSources() {
+    await loader.reload();
+    await session.reload();
+  }
+  return { session, display, reloadSources };
+}
+async function query(folder, question, options) {
+  const { session, display } = await createChat(folder, options);
+  session.setSessionName(`query: ${question}`);
+  display.setQuestion(question);
+  await session.prompt(question);
+  await display.flush();
+  session.dispose();
+  if (options.save) {
+    const sourcesDir = join4(folder, ".llm-kb", "wiki", "sources");
+    const { buildIndex } = await import("./indexer-K37QM2HP.js");
+    await buildIndex(folder, sourcesDir, void 0, options.authStorage);
+  }
+}
+
+export {
+  buildTrace,
+  saveTrace,
+  appendToQueryLog,
+  completeWithFallback,
+  updateWiki,
+  parseCitations,
+  createChat,
+  query
+};