@autorag/librarian 2.9.0 → 2.10.0

package/dist/mcp/index.js

@@ -5607,7 +5607,7 @@ function isGitHubAsset(value) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
-var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.5", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
+var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.6", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
 var init_installer2 = __esm(() => {
   init_process();
   SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/;
@@ -8041,8 +8041,398 @@ var init_model_auth = __esm(() => {
   };
 });
 
+// src/agent/citations.ts
+function isAsciiDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function digitsEndAt(text, from) {
+  let end = from;
+  while (end < text.length && isAsciiDigit(text.charCodeAt(end)))
+    end += 1;
+  return end;
+}
+function continuesAsProse(answer, from) {
+  if (answer[from] !== " " && answer[from] !== " ")
+    return false;
+  const next = answer.codePointAt(from + 1);
+  return next !== undefined && /[\p{L}\p{N}]/u.test(String.fromCodePoint(next));
+}
+function evidenceMarkerAt(answer, index) {
+  const ids = [];
+  let cursor = index + 1;
+  for (;; ) {
+    if (answer[cursor] !== "e")
+      return;
+    const digitsEnd = digitsEndAt(answer, cursor + 1);
+    if (digitsEnd === cursor + 1)
+      return;
+    ids.push(answer.slice(cursor, digitsEnd));
+    cursor = digitsEnd;
+    if (answer[cursor] === "]")
+      return { ids, end: cursor + 1 };
+    if (answer[cursor] !== ",")
+      return;
+    cursor += 1;
+    while (answer[cursor] === " " || answer[cursor] === "\t")
+      cursor += 1;
+  }
+}
+function filePathFrom(raw) {
+  const trimmed = raw.trim();
+  return trimmed.startsWith("<") && trimmed.endsWith(">") ? trimmed.slice(1, -1).trim() : trimmed;
+}
+function fileMarkerAt(answer, index, isFile) {
+  if (!answer.startsWith(FILE_MARKER_PREFIX, index))
+    return;
+  const bodyStart = index + FILE_MARKER_PREFIX.length;
+  let closer = answer.indexOf("]", bodyStart);
+  for (let attempt = 0;closer !== -1 && attempt < MAX_FILE_MARKER_CLOSERS; attempt++) {
+    const path = filePathFrom(answer.slice(bodyStart, closer));
+    if (path.length > 0 && isFile(path))
+      return { path, end: closer + 1 };
+    closer = answer.indexOf("]", closer + 1);
+  }
+  return;
+}
+function answerMarkers(answer, isFile = () => false) {
+  const markers = [];
+  let floor = 0;
+  let closeIndex = -1;
+  let index = 0;
+  const leadingStart = (from) => {
+    let start = from;
+    while (start > floor && (answer[start - 1] === " " || answer[start - 1] === "\t"))
+      start -= 1;
+    return start;
+  };
+  while (index < answer.length) {
+    const char = answer[index];
+    if (char === "(" && answer[index + 1] === "<") {
+      if (closeIndex < index + 2) {
+        const found = answer.indexOf(">", index + 2);
+        closeIndex = found === -1 ? answer.length : found;
+      }
+      if (answer[closeIndex + 1] === ")") {
+        index = closeIndex + 2;
+        floor = index;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "[") {
+      const digitsEnd = digitsEndAt(answer, index + 1);
+      if (digitsEnd > index + 1 && answer[digitsEnd] === "]" && answer[digitsEnd + 1] !== "(" && !continuesAsProse(answer, digitsEnd + 1)) {
+        markers.push({
+          kind: "number",
+          start: leadingStart(index),
+          end: digitsEnd + 1,
+          number: Number(answer.slice(index + 1, digitsEnd))
+        });
+        index = digitsEnd + 1;
+        floor = index;
+        continue;
+      }
+      const evidence = evidenceMarkerAt(answer, index);
+      if (evidence !== undefined && answer[evidence.end] !== "(") {
+        markers.push({ kind: "evidence", start: leadingStart(index), end: evidence.end, ids: evidence.ids });
+        index = evidence.end;
+        floor = index;
+        continue;
+      }
+      const file = fileMarkerAt(answer, index, isFile);
+      if (file !== undefined && answer[file.end] !== "(") {
+        markers.push({ kind: "file", start: leadingStart(index), end: file.end, path: file.path });
+        index = file.end;
+        floor = index;
+        continue;
+      }
+    }
+    index += 1;
+  }
+  return markers;
+}
+function stripUnresolvedCitations(answer, results) {
+  const known = new Set(results.map((result) => result.number));
+  const unresolved = new Set;
+  let stripped = "";
+  let cursor = 0;
+  for (const marker of answerMarkers(answer)) {
+    if (marker.kind !== "number" || known.has(marker.number))
+      continue;
+    unresolved.add(marker.number);
+    stripped += answer.slice(cursor, marker.start);
+    cursor = marker.end;
+  }
+  if (unresolved.size === 0)
+    return { answer, unresolved: [] };
+  return { answer: stripped + answer.slice(cursor), unresolved: [...unresolved].sort((a, b) => a - b) };
+}
+function formatCitationList(numbers) {
+  return numbers.length === 0 ? "none" : numbers.map((number) => `[${number}]`).join(", ");
+}
+function duplicateNumbers(sortedNumbers) {
+  const duplicates = [];
+  for (let index = 1;index < sortedNumbers.length; index++) {
+    const number = sortedNumbers[index];
+    if (number === sortedNumbers[index - 1] && duplicates[duplicates.length - 1] !== number)
+      duplicates.push(number);
+  }
+  return duplicates;
+}
+function assertResultsMappingOneToOne(label, results, mapping) {
+  const resultNumbers = results.map((result) => result.number).sort((a, b) => a - b);
+  const mappingNumbers = mapping.map((entry) => entry.number).sort((a, b) => a - b);
+  const resultDuplicates = duplicateNumbers(resultNumbers);
+  const mappingDuplicates = duplicateNumbers(mappingNumbers);
+  const sameNumbers = resultNumbers.length === mappingNumbers.length && resultNumbers.every((number, index) => number === mappingNumbers[index]);
+  if (sameNumbers && resultDuplicates.length === 0 && mappingDuplicates.length === 0)
+    return;
+  const duplicateNotes = [
+    resultDuplicates.length > 0 ? `results repeat ${formatCitationList(resultDuplicates)}` : undefined,
+    mappingDuplicates.length > 0 ? `mapping repeats ${formatCitationList(mappingDuplicates)}` : undefined
+  ].filter((note) => note !== undefined);
+  throw new Error(`${label}: result numbers and mapping numbers must be one-to-one, but results contain ${formatCitationList(resultNumbers)} ` + `and mapping contains ${formatCitationList(mappingNumbers)}` + (duplicateNotes.length > 0 ? ` (${duplicateNotes.join("; ")})` : "") + ". Give every result a unique number with exactly one mapping entry carrying the same number and no mapping entry without a result.");
+}
+var MAX_FILE_MARKER_CLOSERS = 8, FILE_MARKER_PREFIX = "[file:";
+
+// src/agent/evidence-ledger.ts
+import { createHash as createHash10 } from "node:crypto";
+import { closeSync as closeSync2, openSync as openSync2, readSync, statSync } from "node:fs";
+import { isAbsolute as isAbsolute6 } from "node:path";
+function metadataString(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function metadataNumber(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function isRegularFile2(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function readFileExcerpt(path) {
+  let descriptor;
+  try {
+    descriptor = openSync2(path, "r");
+    const buffer = Buffer.alloc(MAX_CONTENT_CHARS * 4);
+    const bytes = readSync(descriptor, buffer, 0, buffer.length, 0);
+    const head = buffer.subarray(0, bytes);
+    return head.includes(0) ? path : head.toString("utf8").slice(0, MAX_CONTENT_CHARS);
+  } catch {
+    return path;
+  } finally {
+    if (descriptor !== undefined)
+      closeSync2(descriptor);
+  }
+}
+function toEvidenceRef(entry) {
+  return {
+    method: entry.method,
+    source: entry.source,
+    content: entry.content,
+    retrieverMix: [...entry.retrieverMix],
+    ...entry.retrievalResultId !== undefined ? { retrievalResultId: entry.retrievalResultId } : {},
+    ...entry.chunkIndex !== undefined ? { chunkIndex: entry.chunkIndex } : {},
+    ...entry.lineNumber !== undefined ? { lineNumber: entry.lineNumber } : {},
+    ...entry.parserType !== undefined ? { parserType: entry.parserType } : {},
+    ...entry.documentType !== undefined ? { documentType: entry.documentType } : {},
+    ...entry.documentArea !== undefined ? { documentArea: entry.documentArea } : {},
+    ...entry.evidenceType !== undefined ? { evidenceType: entry.evidenceType } : {},
+    ...entry.evidenceLocation !== undefined ? { evidenceLocation: entry.evidenceLocation } : {}
+  };
+}
+
+class EvidenceLedger {
+  entries = [];
+  byKey = new Map;
+  byId = new Map;
+  lastOrdinal = 0;
+  register(input) {
+    const content = input.content.slice(0, MAX_CONTENT_CHARS);
+    const digest = createHash10("sha256").update(input.content.replace(/\s+/gu, " ").trim()).digest("hex");
+    const key = `${input.source}\x00${digest}`;
+    const existing = this.byKey.get(key);
+    if (existing !== undefined) {
+      if (!existing.retrieverMix.includes(input.method))
+        existing.retrieverMix.push(input.method);
+      return existing.id;
+    }
+    const entry = {
+      ...input,
+      content,
+      id: `e${++this.lastOrdinal}`,
+      retrieverMix: [input.method]
+    };
+    this.entries.push(entry);
+    this.byKey.set(key, entry);
+    this.byId.set(entry.id, entry);
+    return entry.id;
+  }
+  registerResult(tool, result) {
+    const metadata = result.metadata;
+    const chunkIndex = metadataNumber(metadata, "chunkIndex");
+    const lineNumber = metadataNumber(metadata, "lineNumber");
+    const parserType = metadataString(metadata, "parserType");
+    const documentType = metadataString(metadata, "documentType");
+    const documentArea = metadataString(metadata, "documentArea");
+    const evidenceType = metadataString(metadata, "evidenceType");
+    const evidenceLocation = metadataString(metadata, "evidenceLocation");
+    return this.register({
+      method: metadataString(metadata, "method") ?? tool,
+      source: result.source,
+      content: result.content,
+      retrievalResultId: result.id,
+      ...chunkIndex !== undefined ? { chunkIndex } : {},
+      ...lineNumber !== undefined ? { lineNumber } : {},
+      ...parserType !== undefined ? { parserType } : {},
+      ...documentType !== undefined ? { documentType } : {},
+      ...documentArea !== undefined ? { documentArea } : {},
+      ...evidenceType !== undefined ? { evidenceType } : {},
+      ...evidenceLocation !== undefined ? { evidenceLocation } : {}
+    });
+  }
+  lookup(raw, options) {
+    const trimmed = raw.trim();
+    const ref = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1).trim() : trimmed;
+    const byId = this.byId.get(ref);
+    if (byId !== undefined)
+      return [toEvidenceRef(byId)];
+    const bySource = this.entries.filter((entry) => entry.source === ref);
+    if (bySource.length > 0)
+      return bySource.map(toEvidenceRef);
+    if (options.allowLocalFiles && isAbsolute6(ref) && isRegularFile2(ref)) {
+      return [{ method: "bash", source: ref, content: readFileExcerpt(ref) }];
+    }
+    return [];
+  }
+  clear() {
+    this.entries = [];
+    this.byKey.clear();
+    this.byId.clear();
+  }
+}
+var MAX_CONTENT_CHARS = 2000;
+var init_evidence_ledger = () => {};
+
+// src/agent/answer-citations.ts
+import { isAbsolute as isAbsolute7 } from "node:path";
+function claimBefore(text, end) {
+  const window = text.slice(Math.max(0, end - CLAIM_LOOKBACK_CHARS), end);
+  const lineStart = window.lastIndexOf(`
+`) + 1;
+  const line = window.slice(lineStart).replace(EVIDENCE_MARKER_TEXT, "");
+  let start = 0;
+  for (let index = line.length - 2;index >= 0; index--) {
+    if (SENTENCE_END.test(line.charAt(index)) && /\s/u.test(line.charAt(index + 1))) {
+      start = index + 2;
+      break;
+    }
+  }
+  const claim = line.slice(start).replace(LEADING_LIST_MARK, "").replace(/\s+/gu, " ").trim();
+  return claim.length > MAX_CLAIM_CHARS ? `${claim.slice(0, MAX_CLAIM_CHARS)}…` : claim;
+}
+function deriveResultsFromAnswer(text, ledger, options) {
+  const isFile = (path) => options.allowLocalFiles && isAbsolute7(path) && isRegularFile2(path);
+  const sources = new Map;
+  const dropped = new Set;
+  let answer = "";
+  let cursor = 0;
+  let lastEmitted;
+  const cite = (reference, claimEnd) => {
+    const refs = ledger.lookup(reference, options);
+    const [primary] = refs;
+    if (primary === undefined) {
+      dropped.add(reference);
+      return;
+    }
+    let cited = sources.get(primary.source);
+    if (cited === undefined) {
+      cited = { number: sources.size + 1, refs: [], chunkKeys: new Set, claim: claimBefore(text, claimEnd) };
+      sources.set(primary.source, cited);
+    }
+    for (const ref of refs) {
+      const chunkKey = `${ref.source}\x00${ref.content ?? ""}`;
+      if (cited.chunkKeys.has(chunkKey))
+        continue;
+      cited.chunkKeys.add(chunkKey);
+      cited.refs.push(ref);
+    }
+    return cited.number;
+  };
+  for (const marker of answerMarkers(text, isFile)) {
+    answer += text.slice(cursor, marker.start);
+    cursor = marker.end;
+    if (marker.kind === "number") {
+      dropped.add(`[${marker.number}]`);
+      continue;
+    }
+    const references = marker.kind === "evidence" ? marker.ids : [`file:${marker.path}`];
+    const numbers = [];
+    for (const reference of references) {
+      const number = cite(marker.kind === "file" ? marker.path : reference, marker.start);
+      if (number !== undefined && !numbers.includes(number))
+        numbers.push(number);
+    }
+    if (numbers.length === 0)
+      continue;
+    const adjacent = lastEmitted !== undefined && text.slice(lastEmitted.end, marker.start).trim() === "";
+    const fresh = numbers.filter((number) => !(adjacent && lastEmitted?.number === number));
+    lastEmitted = { number: numbers[numbers.length - 1], end: marker.end };
+    if (fresh.length === 0)
+      continue;
+    const leading = LEADING_BLANK.exec(text.slice(marker.start, marker.end))?.[0] ?? "";
+    answer += leading + fresh.map((number) => `[${number}]`).join("");
+  }
+  answer += text.slice(cursor);
+  const results = [];
+  const mapping = [];
+  for (const [source, cited] of sources) {
+    const [primary] = cited.refs;
+    if (primary === undefined)
+      continue;
+    results.push({
+      number: cited.number,
+      title: source.split(/[\\/]/u).filter((part) => part.length > 0).pop() ?? source,
+      summary: cited.claim,
+      evidence: cited.refs.map((ref) => {
+        const excerpt = (ref.content ?? "").replace(/\s+/gu, " ").trim().slice(0, MAX_EXCERPT_CHARS);
+        return ref.lineNumber !== undefined ? { excerpt, lineNumber: ref.lineNumber } : { excerpt };
+      })
+    });
+    mapping.push({
+      number: cited.number,
+      source,
+      method: primary.method,
+      content: primary.content ?? "",
+      evidenceRefs: cited.refs
+    });
+  }
+  const diagnostics = dropped.size === 0 ? [] : [
+    {
+      code: "citation-without-result",
+      severity: "warning",
+      message: `Dropped ${dropped.size} answer citation(s) that matched no evidence retrieved in this run: ${[...dropped].join(", ")}. Every remaining citation resolves to a recorded source.`,
+      source: "agent"
+    }
+  ];
+  return { details: { answer: answer.trim(), results, mapping, warnings: [] }, diagnostics };
+}
+var MAX_EXCERPT_CHARS = 400, MAX_CLAIM_CHARS = 280, CLAIM_LOOKBACK_CHARS = 600, SENTENCE_END, LEADING_LIST_MARK, EVIDENCE_MARKER_TEXT, LEADING_BLANK;
+var init_answer_citations = __esm(() => {
+  init_evidence_ledger();
+  SENTENCE_END = /[.!?。！？]/u;
+  LEADING_LIST_MARK = /^[\s\-*•>]+/u;
+  EVIDENCE_MARKER_TEXT = /\[(?:e\d+(?:,\s*)?)+\]|\[file:[^\]]*\]/gu;
+  LEADING_BLANK = /^[ \t]*/u;
+});
+
 // src/agent/answer-guidelines.ts
-var ANSWER_IMAGE_EMBED_RULE = "**Images**: when a retrieved result is itself an image file (png, jpg, jpeg, gif, webp, svg, bmp, avif, heic, tiff) and showing it answers the question, embed it in `answer` as a markdown image on its own line: `![short description](<absolute source path>)`, followed by its citation, e.g. `![Q3 revenue chart](</data/reports/q3 chart.png>) [2]`. Use only the real source path of a result in `results`/`mapping`. Never invent a path, use relative paths, or embed remote URLs. Apart from these image embeds, the no-file-paths rule stands.", ANSWER_IMAGE_DELTA_RULE = "An image already embedded in the first answer must not be embedded again.", ANSWER_CITATION_RULE = "**Citation numbers**: every bracketed citation [n] in `answer` must be the `number` of a result you emit in `results` of the same call. Numbers shown in retrieval candidates or in an earlier first answer are NOT citation numbers — renumber against your own `results`, and add a result for any evidence you cite.";
+var ANSWER_IMAGE_EMBED_RULE = "**Images**: when a retrieved result is itself an image file (png, jpg, jpeg, gif, webp, svg, bmp, avif, heic, tiff) and showing it answers the question, embed it in the answer as a markdown image on its own line: `![short description](<absolute source path>)`, followed by its citation, e.g. `![Q3 revenue chart](</data/reports/q3 chart.png>) [e2]`. Use only the real source path of retrieved evidence. Never invent a path, use relative paths, or embed remote URLs. Apart from these image embeds, the no-file-paths rule stands.", ANSWER_IMAGE_DELTA_RULE = "An image already embedded in the first answer must not be embedded again.", ANSWER_CITATION_RULE = "**Citations**: cite supporting evidence inline with the evidence id shown next to each retrieved result, in square brackets (e.g. [e3], or [e3][e7] for two). Copy ids exactly; never invent one. For a local file you opened yourself with `bash`, cite `[file:<absolute path>]`. Cite the evidence that backs a sentence at the end of that sentence. Do not cite numbers, paths, or anything else.";
 
 // src/agent/datasource-skill.ts
 import { Type as Type2 } from "typebox";
@@ -8243,230 +8633,8 @@ var init_dupey_tool = __esm(() => {
   scanDuplicateDocumentsSchema = Type3.Object({});
 });
 
-// src/agent/citations.ts
-function isAsciiDigit(code) {
-  return code >= 48 && code <= 57;
-}
-function citationMarkers(answer) {
-  const markers = [];
-  let floor = 0;
-  let closeIndex = -1;
-  let index = 0;
-  while (index < answer.length) {
-    const char = answer[index];
-    if (char === "(" && answer[index + 1] === "<") {
-      if (closeIndex < index + 2) {
-        const found = answer.indexOf(">", index + 2);
-        closeIndex = found === -1 ? answer.length : found;
-      }
-      if (answer[closeIndex + 1] === ")") {
-        index = closeIndex + 2;
-        floor = index;
-        continue;
-      }
-      index += 1;
-      continue;
-    }
-    if (char === "[") {
-      let digitsEnd = index + 1;
-      while (digitsEnd < answer.length && isAsciiDigit(answer.charCodeAt(digitsEnd)))
-        digitsEnd += 1;
-      if (digitsEnd > index + 1 && answer[digitsEnd] === "]" && answer[digitsEnd + 1] !== "(") {
-        let start = index;
-        while (start > floor && (answer[start - 1] === " " || answer[start - 1] === "\t"))
-          start -= 1;
-        markers.push({ start, end: digitsEnd + 1, number: Number(answer.slice(index + 1, digitsEnd)) });
-        index = digitsEnd + 1;
-        floor = index;
-        continue;
-      }
-    }
-    index += 1;
-  }
-  return markers;
-}
-function unresolvedCitations(answer, results) {
-  const known = new Set(results.map((result) => result.number));
-  const unresolved = new Set;
-  for (const marker of citationMarkers(answer)) {
-    if (!known.has(marker.number))
-      unresolved.add(marker.number);
-  }
-  return [...unresolved].sort((a, b) => a - b);
-}
-function stripUnresolvedCitations(answer, results) {
-  const known = new Set(results.map((result) => result.number));
-  const unresolved = new Set;
-  let stripped = "";
-  let cursor = 0;
-  for (const marker of citationMarkers(answer)) {
-    if (known.has(marker.number))
-      continue;
-    unresolved.add(marker.number);
-    stripped += answer.slice(cursor, marker.start);
-    cursor = marker.end;
-  }
-  if (unresolved.size === 0)
-    return { answer, unresolved: [] };
-  return { answer: stripped + answer.slice(cursor), unresolved: [...unresolved].sort((a, b) => a - b) };
-}
-function formatCitationList(numbers) {
-  return numbers.length === 0 ? "none" : numbers.map((number) => `[${number}]`).join(", ");
-}
-function duplicateNumbers(sortedNumbers) {
-  const duplicates = [];
-  for (let index = 1;index < sortedNumbers.length; index++) {
-    const number = sortedNumbers[index];
-    if (number === sortedNumbers[index - 1] && duplicates[duplicates.length - 1] !== number)
-      duplicates.push(number);
-  }
-  return duplicates;
-}
-function assertUniqueResultNumbers(label, results) {
-  const duplicates = duplicateNumbers(results.map((result) => result.number).sort((a, b) => a - b));
-  if (duplicates.length === 0)
-    return;
-  throw new Error(`${label}: result numbers must be unique, but results repeat ${formatCitationList(duplicates)}. Give every result its own number and re-emit.`);
-}
-function assertResultsMappingOneToOne(label, results, mapping) {
-  const resultNumbers = results.map((result) => result.number).sort((a, b) => a - b);
-  const mappingNumbers = mapping.map((entry) => entry.number).sort((a, b) => a - b);
-  const resultDuplicates = duplicateNumbers(resultNumbers);
-  const mappingDuplicates = duplicateNumbers(mappingNumbers);
-  const sameNumbers = resultNumbers.length === mappingNumbers.length && resultNumbers.every((number, index) => number === mappingNumbers[index]);
-  if (sameNumbers && resultDuplicates.length === 0 && mappingDuplicates.length === 0)
-    return;
-  const duplicateNotes = [
-    resultDuplicates.length > 0 ? `results repeat ${formatCitationList(resultDuplicates)}` : undefined,
-    mappingDuplicates.length > 0 ? `mapping repeats ${formatCitationList(mappingDuplicates)}` : undefined
-  ].filter((note) => note !== undefined);
-  throw new Error(`${label}: result numbers and mapping numbers must be one-to-one, but results contain ${formatCitationList(resultNumbers)} ` + `and mapping contains ${formatCitationList(mappingNumbers)}` + (duplicateNotes.length > 0 ? ` (${duplicateNotes.join("; ")})` : "") + ". Give every result a unique number with exactly one mapping entry carrying the same number and no mapping entry without a result. Re-emit with consistent numbering.");
-}
-function assertCitationsResolve(label, answer, results) {
-  const unresolved = unresolvedCitations(answer, results);
-  if (unresolved.length === 0)
-    return;
-  const emitted = [...new Set(results.map((result) => result.number))].sort((a, b) => a - b);
-  throw new Error(`${label}: answer cites ${formatCitationList(unresolved)} but results only contain ${formatCitationList(emitted)}. ` + "Every bracketed citation in answer must be the number of a result in results of this same call; " + "candidate numbers from retrieval context or an earlier answer are not citation numbers. Re-emit with consistent numbering.");
-}
-
-// src/agent/emit-results-tool.ts
-import { Type as Type4 } from "typebox";
-function createEmitResultsTool(capture, options) {
-  return {
-    name: EMIT_AUTORAG_RESULTS_TOOL_NAME,
-    label: "Emit AutoRAG Results",
-    description: "Return the final structured AutoRAG answer. Call this exactly once as your last action after searching, reading, and curating. Cite each result's supporting evidence in its refs, using the evidence ids shown next to retrieved results (e.g. e3); the source paths are attached for you. A call whose answer cites a number missing from results, whose result numbers repeat, or whose refs name evidence no tool returned is rejected; fix it and call again.",
-    parameters: emitResultsSchema,
-    async execute(_toolCallId, params) {
-      assertCitationsResolve(EMIT_AUTORAG_RESULTS_TOOL_NAME, params.answer, params.results);
-      assertUniqueResultNumbers(EMIT_AUTORAG_RESULTS_TOOL_NAME, params.results);
-      const mapping = params.results.map((result) => {
-        const evidenceRefs = options.ledger.resolve(result.refs, {
-          label: EMIT_AUTORAG_RESULTS_TOOL_NAME,
-          number: result.number,
-          fallbackContent: result.evidence.map((evidence) => evidence.excerpt).join(`
-`) || result.summary,
-          allowLocalFiles: options.allowLocalFiles
-        });
-        const primary = evidenceRefs[0];
-        if (primary === undefined) {
-          throw new Error(`${EMIT_AUTORAG_RESULTS_TOOL_NAME}: result ${result.number} resolved no evidence. Give it at least one valid ref.`);
-        }
-        return {
-          number: result.number,
-          source: primary.source,
-          method: primary.method,
-          content: primary.content ?? "",
-          evidenceRefs
-        };
-      });
-      const details = {
-        answer: params.answer,
-        results: params.results.map((result) => ({
-          number: result.number,
-          title: result.title,
-          summary: result.summary,
-          evidence: result.evidence.map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
-          confidence: result.confidence
-        })),
-        mapping,
-        warnings: params.warnings ?? []
-      };
-      capture(details);
-      return {
-        content: [{ type: "text", text: "AutoRAG results emitted." }],
-        details,
-        terminate: true
-      };
-    }
-  };
-}
-var EMIT_AUTORAG_RESULTS_TOOL_NAME = "emit_autorag_results", evidenceRefSchema, answerSchema, warningsSchema, curatedResultFields, emitResultsSchema, reportSchema;
-var init_emit_results_tool = __esm(() => {
-  evidenceRefSchema = Type4.Object({
-    method: Type4.String({ description: "Retrieval method namespace for this evidence chunk" }),
-    source: Type4.String({ description: "Internal opaque source identifier for this evidence chunk" }),
-    excerpt: Type4.Optional(Type4.String({ description: "Evidence excerpt used for stable ID normalization" })),
-    content: Type4.Optional(Type4.String({ description: "Evidence content used for stable ID normalization" })),
-    retrievalResultId: Type4.Optional(Type4.String({ description: "Backend retrieval ID when path-opaque and stable" })),
-    chunkIndex: Type4.Optional(Type4.Integer({ description: "Chunk index, if available" })),
-    lineNumber: Type4.Optional(Type4.Integer({ description: "Line number, if available" })),
-    stableEvidenceId: Type4.Optional(Type4.String({ description: "Stable evidence ID, if already normalized" })),
-    retrieverMix: Type4.Optional(Type4.Array(Type4.String({ maxLength: 64 }), {
-      description: "Retrievers that contributed to this result",
-      maxItems: 8
-    })),
-    parserType: Type4.Optional(Type4.String({ description: "Parser that produced this evidence", maxLength: 120 })),
-    documentType: Type4.Optional(Type4.String({ description: "Document type, if known", maxLength: 120 })),
-    documentArea: Type4.Optional(Type4.String({ description: "Document collection area, if known", maxLength: 120 })),
-    evidenceType: Type4.Optional(Type4.String({ description: "Evidence type, if known", maxLength: 120 })),
-    evidenceLocation: Type4.Optional(Type4.String({ description: "Human-readable evidence location", maxLength: 120 })),
-    confidence: Type4.Optional(Type4.Number({ description: "Evidence confidence, 0..1", minimum: 0, maximum: 1 }))
-  });
-  answerSchema = Type4.String({
-    description: `Answer for the caller. When a first answer was already delivered to the caller during this run, this MUST contain only the corrections and newly verified findings relative to it — never restate the first answer; otherwise it is the complete answer. At most 5 bullet points (plus optional explanation); reference results by bracketed number (e.g. [1], [2]) without file paths or raw chunk text, except the image-embed exception below. ${ANSWER_CITATION_RULE} ${ANSWER_IMAGE_EMBED_RULE} ${ANSWER_IMAGE_DELTA_RULE}`
-  });
-  warningsSchema = Type4.Optional(Type4.Array(Type4.String(), { description: "Optional warnings about this result set" }));
-  curatedResultFields = {
-    number: Type4.Integer({ description: "1-based result number" }),
-    title: Type4.String({ description: "Short name of the curated knowledge unit" }),
-    summary: Type4.String({ description: "Key insight: purpose, details, and line range" }),
-    evidence: Type4.Array(Type4.Object({
-      excerpt: Type4.String({ description: "Supporting excerpt" }),
-      lineNumber: Type4.Optional(Type4.Integer({ description: "Line number of the excerpt, if known" }))
-    })),
-    confidence: Type4.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 })
-  };
-  emitResultsSchema = Type4.Object({
-    answer: answerSchema,
-    results: Type4.Array(Type4.Object({
-      ...curatedResultFields,
-      refs: Type4.Array(Type4.String(), {
-        minItems: 1,
-        description: "Evidence ids supporting this result, copied from the ids shown next to retrieved results (e.g. e3). For a local file you opened yourself with bash, give its absolute path instead."
-      })
-    }), { description: "Numbered curated knowledge units." }),
-    warnings: warningsSchema
-  });
-  reportSchema = Type4.Object({
-    answer: answerSchema,
-    results: Type4.Array(Type4.Object(curatedResultFields), { description: "Numbered curated knowledge units." }),
-    mapping: Type4.Array(Type4.Object({
-      number: Type4.Integer({ description: "Matches the result number this entry maps" }),
-      source: Type4.String({ description: "Source identifier — a real file path or a datasource id" }),
-      method: Type4.String({ description: "Retrieval method or tool that produced the source" }),
-      content: Type4.String({ description: "Raw content snippet of the evidence behind this result" }),
-      evidenceRefs: Type4.Optional(Type4.Array(evidenceRefSchema, {
-        description: "Hidden evidence chunk references supporting this curated result"
-      }))
-    }), { description: "Internal number -> source/method mapping. One entry per result number." }),
-    warnings: warningsSchema
-  });
-});
-
 // src/agent/everything-search-tool.ts
-import { Type as Type5 } from "typebox";
+import { Type as Type4 } from "typebox";
 function createEverythingSearchTool(provider) {
   return {
     name: EVERYTHING_SEARCH_TOOL_NAME,
@@ -8518,28 +8686,28 @@ ${lines.join(`
 }
 var EVERYTHING_SEARCH_TOOL_NAME = "everything_search", MAX_RESULTS_CAP2 = 1000, DEFAULT_MAX_RESULTS3 = 100, everythingSearchSchema;
 var init_everything_search_tool = __esm(() => {
-  everythingSearchSchema = Type5.Object({
-    query: Type5.String({
+  everythingSearchSchema = Type4.Object({
+    query: Type4.String({
       description: 'Everything search syntax over file and folder names: space = AND, | = OR, ! = NOT, "quoted phrase", wildcards (*.pdf), ext:pdf;docx, dm:thisweek, size:>10mb, parent:<folder>, path fragments like \\reports\\ when matchPath is true.'
     }),
-    regex: Type5.Optional(Type5.Boolean({ description: "Treat query as a regular expression." })),
-    matchCase: Type5.Optional(Type5.Boolean()),
-    matchPath: Type5.Optional(Type5.Boolean({ description: "Match against the full path instead of the name." })),
-    wholeWord: Type5.Optional(Type5.Boolean()),
-    kind: Type5.Optional(Type5.Union([Type5.Literal("files"), Type5.Literal("folders")])),
-    path: Type5.Optional(Type5.String({ description: "Absolute folder to search within." })),
-    sort: Type5.Optional(Type5.Union([
-      Type5.Literal("name-ascending"),
-      Type5.Literal("name-descending"),
-      Type5.Literal("path-ascending"),
-      Type5.Literal("path-descending"),
-      Type5.Literal("size-ascending"),
-      Type5.Literal("size-descending"),
-      Type5.Literal("date-modified-ascending"),
-      Type5.Literal("date-modified-descending")
+    regex: Type4.Optional(Type4.Boolean({ description: "Treat query as a regular expression." })),
+    matchCase: Type4.Optional(Type4.Boolean()),
+    matchPath: Type4.Optional(Type4.Boolean({ description: "Match against the full path instead of the name." })),
+    wholeWord: Type4.Optional(Type4.Boolean()),
+    kind: Type4.Optional(Type4.Union([Type4.Literal("files"), Type4.Literal("folders")])),
+    path: Type4.Optional(Type4.String({ description: "Absolute folder to search within." })),
+    sort: Type4.Optional(Type4.Union([
+      Type4.Literal("name-ascending"),
+      Type4.Literal("name-descending"),
+      Type4.Literal("path-ascending"),
+      Type4.Literal("path-descending"),
+      Type4.Literal("size-ascending"),
+      Type4.Literal("size-descending"),
+      Type4.Literal("date-modified-ascending"),
+      Type4.Literal("date-modified-descending")
     ])),
-    offset: Type5.Optional(Type5.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
-    maxResults: Type5.Optional(Type5.Integer({
+    offset: Type4.Optional(Type4.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
+    maxResults: Type4.Optional(Type4.Integer({
       minimum: 1,
       description: `Maximum results (default ${DEFAULT_MAX_RESULTS3}, cap ${MAX_RESULTS_CAP2}).`
     }))
@@ -8671,146 +8839,6 @@ var init_evidence_judgment = __esm(() => {
   };
 });
 
-// src/agent/evidence-ledger.ts
-import { createHash as createHash10 } from "node:crypto";
-import { statSync } from "node:fs";
-import { isAbsolute as isAbsolute6 } from "node:path";
-function metadataString(metadata, key) {
-  const value = metadata[key];
-  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function metadataNumber(metadata, key) {
-  const value = metadata[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function isRegularFile2(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-function toEvidenceRef(entry) {
-  return {
-    method: entry.method,
-    source: entry.source,
-    content: entry.content,
-    retrieverMix: [...entry.retrieverMix],
-    ...entry.retrievalResultId !== undefined ? { retrievalResultId: entry.retrievalResultId } : {},
-    ...entry.chunkIndex !== undefined ? { chunkIndex: entry.chunkIndex } : {},
-    ...entry.lineNumber !== undefined ? { lineNumber: entry.lineNumber } : {},
-    ...entry.parserType !== undefined ? { parserType: entry.parserType } : {},
-    ...entry.documentType !== undefined ? { documentType: entry.documentType } : {},
-    ...entry.documentArea !== undefined ? { documentArea: entry.documentArea } : {},
-    ...entry.evidenceType !== undefined ? { evidenceType: entry.evidenceType } : {},
-    ...entry.evidenceLocation !== undefined ? { evidenceLocation: entry.evidenceLocation } : {}
-  };
-}
-
-class EvidenceLedger {
-  entries = [];
-  byKey = new Map;
-  byId = new Map;
-  lastOrdinal = 0;
-  register(input) {
-    const content = input.content.slice(0, MAX_CONTENT_CHARS);
-    const digest = createHash10("sha256").update(input.content.replace(/\s+/gu, " ").trim()).digest("hex");
-    const key = `${input.source}\x00${digest}`;
-    const existing = this.byKey.get(key);
-    if (existing !== undefined) {
-      if (!existing.retrieverMix.includes(input.method))
-        existing.retrieverMix.push(input.method);
-      return existing.id;
-    }
-    const entry = {
-      ...input,
-      content,
-      id: `e${++this.lastOrdinal}`,
-      retrieverMix: [input.method]
-    };
-    this.entries.push(entry);
-    this.byKey.set(key, entry);
-    this.byId.set(entry.id, entry);
-    return entry.id;
-  }
-  registerResult(tool, result) {
-    const metadata = result.metadata;
-    const chunkIndex = metadataNumber(metadata, "chunkIndex");
-    const lineNumber = metadataNumber(metadata, "lineNumber");
-    const parserType = metadataString(metadata, "parserType");
-    const documentType = metadataString(metadata, "documentType");
-    const documentArea = metadataString(metadata, "documentArea");
-    const evidenceType = metadataString(metadata, "evidenceType");
-    const evidenceLocation = metadataString(metadata, "evidenceLocation");
-    return this.register({
-      method: metadataString(metadata, "method") ?? tool,
-      source: result.source,
-      content: result.content,
-      retrievalResultId: result.id,
-      ...chunkIndex !== undefined ? { chunkIndex } : {},
-      ...lineNumber !== undefined ? { lineNumber } : {},
-      ...parserType !== undefined ? { parserType } : {},
-      ...documentType !== undefined ? { documentType } : {},
-      ...documentArea !== undefined ? { documentArea } : {},
-      ...evidenceType !== undefined ? { evidenceType } : {},
-      ...evidenceLocation !== undefined ? { evidenceLocation } : {}
-    });
-  }
-  resolve(refs, options) {
-    const resolved = [];
-    const seen = new Set;
-    const push = (entry) => {
-      if (seen.has(entry.id))
-        return;
-      seen.add(entry.id);
-      resolved.push(toEvidenceRef(entry));
-    };
-    for (const raw of refs) {
-      const trimmed = raw.trim();
-      const ref = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1).trim() : trimmed;
-      const byId = this.byId.get(ref);
-      if (byId !== undefined) {
-        push(byId);
-        continue;
-      }
-      const bySource = this.entries.filter((entry) => entry.source === ref);
-      if (bySource.length > 0) {
-        for (const entry of bySource)
-          push(entry);
-        continue;
-      }
-      if (options.allowLocalFiles && isAbsolute6(ref) && isRegularFile2(ref)) {
-        const key = `file\x00${ref}`;
-        if (seen.has(key))
-          continue;
-        seen.add(key);
-        resolved.push({
-          method: "bash",
-          source: ref,
-          content: (options.fallbackContent.trim() || ref).slice(0, MAX_CONTENT_CHARS)
-        });
-        continue;
-      }
-      throw new Error(this.unresolvedMessage(ref, EVIDENCE_ID_PATTERN.test(ref), options));
-    }
-    return resolved;
-  }
-  clear() {
-    this.entries = [];
-    this.byKey.clear();
-    this.byId.clear();
-  }
-  unresolvedMessage(ref, looksLikeId, options) {
-    const known = this.entries.length === 0 ? "No search or fetch has returned evidence in this run yet." : `Evidence ids issued in this run: ${this.entries[0]?.id}${this.entries.length > 1 ? `..${this.entries[this.entries.length - 1]?.id}` : ""}.`;
-    const local = options.allowLocalFiles ? " For a file you opened yourself with bash, pass its absolute path." : "";
-    return `${options.label}: result ${options.number} cites evidence "${ref}" that no tool returned in this run` + `${looksLikeId ? " (unknown evidence id)" : ""}. ${known} ` + `Cite only the evidence ids shown next to retrieved results (e.g. e3).${local} Re-emit with valid refs.`;
-  }
-}
-var MAX_CONTENT_CHARS = 2000, EVIDENCE_ID_PATTERN;
-var init_evidence_ledger = __esm(() => {
-  EVIDENCE_ID_PATTERN = /^e\d+$/u;
-});
-
 // src/agent/evidence-origins.ts
 function normalize3(text) {
   return text.normalize("NFC").toLowerCase().replace(/\s+/g, " ").trim();
@@ -8909,170 +8937,690 @@ class EvidenceOriginIndex {
         }
       }
     }
-    return;
+    return;
+  }
+  clear() {
+    this.candidates.length = 0;
+    this.seen.clear();
+  }
+}
+var MAX_CANDIDATES = 2000, MAX_CONTENT_LENGTH = 4000, MIN_MATCH_LENGTH = 12;
+
+// src/agent/fsearch-search-tool.ts
+import { Type as Type5 } from "typebox";
+function createFSearchSearchTool(provider) {
+  return {
+    name: FSEARCH_SEARCH_TOOL_NAME,
+    label: "FSearch Search",
+    description: "Instantly find files and folders by name, extension, path, size, or modified date across the configured search folders using fsearch-cli/FSearch (macOS/Linux), falling back to a slow filesystem walk when fsearch-cli is not installed. Returns absolute paths; read file contents with bash.",
+    parameters: fsearchSearchSchema,
+    async execute(_toolCallId, params) {
+      const query = params.query.trim();
+      if (query.length === 0) {
+        return {
+          content: [{ type: "text", text: "FSearch query was empty; nothing searched." }],
+          details: { method: FSEARCH_SEARCH_TOOL_NAME, resultCount: 0, sources: [], results: [] }
+        };
+      }
+      const request = {
+        ...params,
+        query,
+        maxResults: Math.min(params.maxResults ?? DEFAULT_MAX_RESULTS4, MAX_RESULTS_CAP3)
+      };
+      const result = await provider.searchFsearch(request);
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: `FSearch ${result.reason}: ${result.message}` }],
+          details: { method: FSEARCH_SEARCH_TOOL_NAME, resultCount: 0, sources: [], results: [] }
+        };
+      }
+      const lines = result.results.map((entry, index) => {
+        const parts = [`[${index + 1}] ${entry.type} ${entry.path}`];
+        if (entry.size !== undefined)
+          parts.push(`size=${entry.size}`);
+        if (entry.dateModified !== undefined)
+          parts.push(`modified=${entry.dateModified}`);
+        return parts.join(" ");
+      });
+      const backendLabel = result.backend === "walk" ? "FSearch slow filesystem walk (fsearch-cli unavailable)" : "FSearch";
+      const limitNote = result.backend === "fsearch-cli" && (result.total ?? 0) > lines.length && lines.length === request.maxResults ? ` of ${result.total} total (limit reached; narrow the query or page with offset)` : "";
+      const noteSuffix = result.note !== undefined ? `
+${result.note}` : "";
+      const text = lines.length === 0 ? `${backendLabel} found no files or folders matching: ${query}${noteSuffix}` : `${backendLabel} found ${lines.length} item(s)${limitNote}:
+${lines.join(`
+`)}${noteSuffix}`;
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          method: FSEARCH_SEARCH_TOOL_NAME,
+          resultCount: result.results.length,
+          sources: result.results.map((entry) => entry.path),
+          results: result.results.map((entry, index) => ({ source: entry.path, excerpt: lines[index] }))
+        }
+      };
+    }
+  };
+}
+var FSEARCH_SEARCH_TOOL_NAME = "fsearch_search", MAX_RESULTS_CAP3 = 1000, DEFAULT_MAX_RESULTS4 = 100, fsearchSearchSchema;
+var init_fsearch_search_tool = __esm(() => {
+  fsearchSearchSchema = Type5.Object({
+    query: Type5.String({
+      description: 'FSearch query syntax over file and folder names: space = AND, OR keyword = OR (never the pipe |), ! = NOT, "quoted phrase", wildcards (*.pdf), ext:pdf;docx, size:>10mb, path:<fragment>, case:, regex:. When the slow-walk fallback answers (fsearch-cli not installed), only substring/regex name matching applies.'
+    }),
+    regex: Type5.Optional(Type5.Boolean({ description: "Treat query as a regular expression." })),
+    matchCase: Type5.Optional(Type5.Boolean()),
+    matchPath: Type5.Optional(Type5.Boolean({ description: "Match against the full path instead of the name." })),
+    kind: Type5.Optional(Type5.Union([Type5.Literal("files"), Type5.Literal("folders")])),
+    path: Type5.Optional(Type5.String({ description: "Absolute folder to search within." })),
+    sort: Type5.Optional(Type5.Union([
+      Type5.Literal("name-ascending"),
+      Type5.Literal("name-descending"),
+      Type5.Literal("path-ascending"),
+      Type5.Literal("path-descending"),
+      Type5.Literal("size-ascending"),
+      Type5.Literal("size-descending"),
+      Type5.Literal("date-modified-ascending"),
+      Type5.Literal("date-modified-descending")
+    ])),
+    offset: Type5.Optional(Type5.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
+    maxResults: Type5.Optional(Type5.Integer({
+      minimum: 1,
+      description: `Maximum results (default ${DEFAULT_MAX_RESULTS4}, cap ${MAX_RESULTS_CAP3}).`
+    }))
+  });
+});
+
+// src/cloud/config.ts
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47)
+    end--;
+  return trimmed.slice(0, end);
+}
+function resolveBaseUrl(env) {
+  const configured = env[AUTORAG_BASE_URL_ENV];
+  const value = typeof configured === "string" && configured.trim() !== "" ? configured : DEFAULT_BASE_URL;
+  return normalizeBaseUrl(value);
+}
+var PROVIDER_ID = "autorag", PROVIDER_NAME = "AutoRAG", DEFAULT_BASE_URL = "https://api.dazziapp.com", AUTORAG_BASE_URL_ENV = "AUTORAG_BASE_URL", AUTORAG_API_KEY_ENV = "AUTORAG_API_KEY", API_PATH = "/v1", MODELS_PATH = "/v1/models", AUTHORIZE_PATH = "/desktop/authorize", TOKEN_PATH = "/api/desktop/token", OAUTH_CLIENT_ID = "agent", API_KEY_CONFIG_VALUE;
+var init_config = __esm(() => {
+  API_KEY_CONFIG_VALUE = `$${AUTORAG_API_KEY_ENV}`;
+});
+
+// src/cloud/errors.ts
+function extractErrorPayload(body) {
+  if (typeof body !== "object" || body === null)
+    return {};
+  const record = body;
+  const error = record.error;
+  if (typeof error === "string")
+    return error.length > 0 ? { message: error } : {};
+  if (typeof error === "object" && error !== null) {
+    const inner = error;
+    const payload = {};
+    if (typeof inner.message === "string")
+      payload.message = inner.message;
+    if (typeof inner.code === "string")
+      payload.code = inner.code;
+    if (typeof inner.type === "string")
+      payload.type = inner.type;
+    return payload;
+  }
+  return typeof record.message === "string" ? { message: record.message } : {};
+}
+var AutoragError, AutoragOAuthError, AutoragHttpError;
+var init_errors3 = __esm(() => {
+  AutoragError = class AutoragError extends Error {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "AutoragError";
+    }
+  };
+  AutoragOAuthError = class AutoragOAuthError extends AutoragError {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "AutoragOAuthError";
+    }
+  };
+  AutoragHttpError = class AutoragHttpError extends AutoragError {
+    status;
+    code;
+    type;
+    constructor(message, options) {
+      super(message, { cause: options.cause });
+      this.name = "AutoragHttpError";
+      this.status = options.status;
+      if (options.code !== undefined)
+        this.code = options.code;
+      if (options.type !== undefined)
+        this.type = options.type;
+    }
+  };
+});
+
+// src/cloud/models.ts
+function resolveCredentialKey(credential) {
+  if (credential === undefined)
+    return;
+  const value = credential.type === "oauth" ? credential.access : credential.key;
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+async function fetchModels(options) {
+  const doFetch = options.fetchImpl ?? fetch;
+  let response;
+  try {
+    response = await doFetch(`${normalizeBaseUrl(options.baseUrl)}${MODELS_PATH}`, {
+      headers: { authorization: `Bearer ${options.apiKey}`, accept: "application/json" },
+      signal: options.signal
+    });
+  } catch (cause) {
+    if (options.signal?.aborted) {
+      throw new AutoragOAuthError("AutoRAG model refresh was cancelled.", { cause });
+    }
+    throw new AutoragOAuthError(`AutoRAG model listing could not reach ${normalizeBaseUrl(options.baseUrl)}.`, {
+      cause
+    });
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = undefined;
+  }
+  if (!response.ok)
+    throw mapModelsError(response.status, body);
+  return mapServerModels(body);
+}
+function mapModelsError(status, body) {
+  const payload = extractErrorPayload(body);
+  if (status === 401) {
+    return new AutoragHttpError("AutoRAG rejected the API key (HTTP 401). Run /login again or set AUTORAG_API_KEY.", {
+      status,
+      code: payload.code ?? "unauthorized",
+      type: payload.type
+    });
+  }
+  const reason = payload.message ?? "the server returned no error message";
+  return new AutoragHttpError(`AutoRAG model listing failed (HTTP ${status}): ${reason}`, {
+    status,
+    code: payload.code,
+    type: payload.type
+  });
+}
+function mapServerModels(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return [];
+  const data = payload.data;
+  if (!Array.isArray(data))
+    return [];
+  const models = [];
+  for (const entry of data) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    const model = mapServerModel(entry);
+    if (model !== undefined)
+      models.push(model);
+  }
+  return models;
+}
+function mapServerModel(entry) {
+  const id = readString2(entry.id);
+  if (id === undefined)
+    return;
+  return {
+    type: "chat",
+    id,
+    name: readString2(entry.name) ?? id,
+    input: readInputModalities(entry.input_modalities),
+    cost: readPricing(entry.pricing),
+    reasoning: entry.reasoning === true,
+    contextWindow: readPositiveNumber(entry.context_window) ?? DEFAULT_CONTEXT_WINDOW,
+    maxTokens: readPositiveNumber(entry.max_output_tokens) ?? DEFAULT_MAX_TOKENS
+  };
+}
+function buildStoreEntry(models, providerId, baseUrl) {
+  const stored = [];
+  for (const model of models) {
+    if (model.type === "image" || model.type === "classifier")
+      continue;
+    stored.push({
+      type: "chat",
+      id: model.id,
+      name: model.name,
+      api: model.api ?? "openai-responses",
+      provider: providerId,
+      baseUrl: model.baseUrl ?? baseUrl,
+      input: model.input,
+      cost: model.cost,
+      reasoning: model.reasoning,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens
+    });
+  }
+  return { models: stored, checkedAt: Date.now() };
+}
+function modelsFromStore(stored) {
+  if (stored === undefined)
+    return [];
+  const models = [];
+  for (const entry of stored.models) {
+    if (entry.type === "image" || entry.type === "classifier")
+      continue;
+    models.push({
+      type: "chat",
+      id: entry.id,
+      name: entry.name,
+      input: entry.input,
+      cost: entry.cost,
+      reasoning: entry.reasoning,
+      contextWindow: entry.contextWindow,
+      maxTokens: entry.maxTokens
+    });
+  }
+  return models;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+}
+function readPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function readInputModalities(value) {
+  if (!Array.isArray(value))
+    return ["text"];
+  const modalities = value.filter((item) => item === "text" || item === "image");
+  const unique = Array.from(new Set(modalities));
+  return unique.length > 0 ? unique : ["text"];
+}
+function readPricing(value) {
+  const pricing = typeof value === "object" && value !== null ? value : {};
+  return {
+    input: readPositiveNumber(pricing.input) ?? 0,
+    output: readPositiveNumber(pricing.output) ?? 0,
+    cacheRead: readPositiveNumber(pricing.cache_read) ?? 0,
+    cacheWrite: readPositiveNumber(pricing.cache_write) ?? 0
+  };
+}
+var DEFAULT_CONTEXT_WINDOW = 128000, DEFAULT_MAX_TOKENS = 16384;
+var init_models = __esm(() => {
+  init_config();
+  init_errors3();
+});
+
+// src/cloud/authorize.ts
+function buildAuthorizeUrl(params) {
+  const url = new URL(`${normalizeBaseUrl(params.baseUrl)}${AUTHORIZE_PATH}`);
+  url.searchParams.set("client", OAUTH_CLIENT_ID);
+  url.searchParams.set("redirect_uri", params.redirectUri);
+  url.searchParams.set("state", params.state);
+  url.searchParams.set("code_challenge", params.codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  return url.toString();
+}
+var init_authorize = __esm(() => {
+  init_config();
+});
+
+// src/cloud/callback.ts
+function parseCallbackQuery(params) {
+  const result = {};
+  const code = params.get("code");
+  const error = params.get("error");
+  const state = params.get("state");
+  if (code !== null && code !== "")
+    result.code = code;
+  if (error !== null && error !== "")
+    result.error = error;
+  if (state !== null && state !== "")
+    result.state = state;
+  return result;
+}
+function parseCallbackInput(input) {
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    throw new AutoragOAuthError("AutoRAG sign-in failed: nothing was pasted.");
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      return parseCallbackQuery(new URL(trimmed).searchParams);
+    } catch {
+      throw new AutoragOAuthError("AutoRAG sign-in failed: the pasted URL is not valid.");
+    }
+  }
+  const query = trimmed.startsWith("?") ? trimmed.slice(1) : trimmed;
+  if (!query.includes(" ")) {
+    const params = new URLSearchParams(query);
+    if (params.has("code") || params.has("error") || params.has("state")) {
+      return parseCallbackQuery(params);
+    }
+  }
+  return { code: trimmed };
+}
+function requireAuthorizationCode(result, expectedState) {
+  if (result.state !== undefined && result.state !== expectedState) {
+    throw new AutoragOAuthError("AutoRAG sign-in failed: state mismatch (the callback did not originate from this login attempt).");
+  }
+  if (result.error !== undefined) {
+    throw new AutoragOAuthError(result.error === "access_denied" ? "AutoRAG sign-in was cancelled in the browser." : `AutoRAG sign-in failed: ${result.error}.`);
+  }
+  if (result.code === undefined) {
+    throw new AutoragOAuthError("AutoRAG sign-in failed: the callback carried no authorization code.");
+  }
+  return { code: result.code };
+}
+var init_callback = __esm(() => {
+  init_errors3();
+});
+
+// src/cloud/callback-server.ts
+import { createServer as createServer3 } from "node:http";
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function renderCallbackPage(failed) {
+  const message = failed ? "AutoRAG sign-in did not complete. You can close this tab and try again." : "Signed in to AutoRAG. You can close this tab.";
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    "<title>AutoRAG</title>",
+    "</head>",
+    '<body style="font-family: system-ui, sans-serif; margin: 4rem auto; max-width: 32rem; text-align: center;">',
+    `<p>${message}</p>`,
+    "</body>",
+    "</html>"
+  ].join(`
+`);
+}
+function startCallbackServer(options) {
+  const host = options.host ?? "127.0.0.1";
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS;
+  const server = createServer3();
+  const started = createDeferred();
+  const callback = createDeferred();
+  callback.promise.catch(() => {});
+  let finished = false;
+  let startSettled = false;
+  let timer;
+  function cleanup() {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+    if (server.listening) {
+      server.closeAllConnections();
+      server.close();
+    }
+  }
+  function fail(error) {
+    if (finished)
+      return;
+    finished = true;
+    cleanup();
+    callback.reject(error);
+  }
+  function onAbort() {
+    fail(new AutoragOAuthError("AutoRAG sign-in was cancelled."));
+  }
+  server.on("request", (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${host}`);
+    if (req.method !== "GET" || url.pathname !== CALLBACK_PATH) {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Not found");
+      return;
+    }
+    if (finished) {
+      res.writeHead(410, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Callback already handled");
+      return;
+    }
+    const params = url.searchParams;
+    const code = params.get("code");
+    const oauthError = params.get("error");
+    const hasResponse = code !== null && code !== "" || oauthError !== null && oauthError !== "";
+    if (params.get("state") !== options.state || !hasResponse) {
+      res.writeHead(400, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+      res.end(renderCallbackPage(true));
+      return;
+    }
+    finished = true;
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+    res.end(renderCallbackPage(params.has("error")));
+    cleanup();
+    callback.resolve(params);
+  });
+  server.on("error", (error) => {
+    const wrapped = error instanceof Error ? error : new Error(String(error));
+    if (!startSettled) {
+      startSettled = true;
+      cleanup();
+      started.reject(wrapped);
+      return;
+    }
+    fail(wrapped);
+  });
+  server.listen(0, host, () => {
+    const address = server.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    const redirectUri = `http://${host}:${port}${CALLBACK_PATH}`;
+    timer = setTimeout(() => fail(new AutoragOAuthError("AutoRAG sign-in timed out waiting for the browser callback.")), timeoutMs);
+    if (options.signal?.aborted)
+      onAbort();
+    else
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    startSettled = true;
+    options.onListening?.(redirectUri);
+    started.resolve({
+      redirectUri,
+      waitForCallback: () => callback.promise,
+      close: () => {
+        if (!finished)
+          fail(new AutoragOAuthError("AutoRAG sign-in was cancelled."));
+      }
+    });
+  });
+  return started.promise;
+}
+var CALLBACK_PATH = "/callback", DEFAULT_LOGIN_TIMEOUT_MS;
+var init_callback_server = __esm(() => {
+  init_errors3();
+  DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+});
+
+// src/cloud/pkce.ts
+import { createHash as createHash11, randomBytes } from "node:crypto";
+function base64UrlEncode(bytes) {
+  return Buffer.from(bytes).toString("base64url");
+}
+function createCodeChallenge(verifier) {
+  return base64UrlEncode(createHash11("sha256").update(verifier, "ascii").digest());
+}
+function createCodeVerifier(byteLength = 32) {
+  return base64UrlEncode(randomBytes(byteLength));
+}
+function createState(byteLength = 24) {
+  return base64UrlEncode(randomBytes(byteLength));
+}
+function createPkcePair(byteLength = 32) {
+  const verifier = createCodeVerifier(byteLength);
+  return { verifier, challenge: createCodeChallenge(verifier) };
+}
+var init_pkce = () => {};
+
+// src/cloud/token.ts
+function mapTokenExchangeError(status, body) {
+  const payload = extractErrorPayload(body);
+  const reason = payload.message ?? "the server returned no error message";
+  return new AutoragHttpError(`AutoRAG token exchange failed (HTTP ${status}): ${reason}`, {
+    status,
+    code: payload.code,
+    type: payload.type
+  });
+}
+async function exchangeCodeForToken(options) {
+  const doFetch = options.fetchImpl ?? fetch;
+  let response;
+  try {
+    response = await doFetch(`${normalizeBaseUrl(options.baseUrl)}${TOKEN_PATH}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify({
+        code: options.code,
+        code_verifier: options.codeVerifier,
+        redirect_uri: options.redirectUri
+      }),
+      signal: options.signal
+    });
+  } catch (cause) {
+    if (options.signal?.aborted) {
+      throw new AutoragOAuthError("AutoRAG sign-in was cancelled.", { cause });
+    }
+    throw new AutoragOAuthError(`AutoRAG token exchange could not reach ${normalizeBaseUrl(options.baseUrl)}.`, {
+      cause
+    });
   }
-  clear() {
-    this.candidates.length = 0;
-    this.seen.clear();
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = undefined;
   }
+  if (!response.ok)
+    throw mapTokenExchangeError(response.status, body);
+  const accessToken = readAccessToken(body);
+  if (accessToken === undefined) {
+    throw new AutoragOAuthError("AutoRAG token exchange succeeded but returned no access token.");
+  }
+  const email = readEmail(body);
+  return email === undefined ? { accessToken } : { accessToken, email };
 }
-var MAX_CANDIDATES = 2000, MAX_CONTENT_LENGTH = 4000, MIN_MATCH_LENGTH = 12;
-
-// src/agent/fast-answer-tool.ts
-import { Type as Type6 } from "typebox";
-function createEmitFastAnswerTool(capture, options) {
-  return {
-    name: EMIT_FAST_ANSWER_TOOL_NAME,
-    label: "Emit Fast Answer",
-    description: "Deliver the immediate first answer to the user. Call this exactly once during the fast phase with a complete, self-contained answer built only from the baseline retrieval evidence. Do not call any other tool before this one. The run continues afterwards for verification. A call whose answer cites a number missing from results, or whose refs name evidence that was not provided, is rejected; fix it and call again.",
-    parameters: fastAnswerSchema,
-    async execute(_toolCallId, params) {
-      assertCitationsResolve(EMIT_FAST_ANSWER_TOOL_NAME, params.answer, params.results);
-      const evidenceRefs = [];
-      for (const result of params.results) {
-        if (result.refs === undefined || result.refs.length === 0)
-          continue;
-        const refs = options.ledger.resolve(result.refs, {
-          label: EMIT_FAST_ANSWER_TOOL_NAME,
-          number: result.number,
-          fallbackContent: result.summary,
-          allowLocalFiles: false
-        });
-        if (refs.length > 0)
-          evidenceRefs.push({ number: result.number, refs });
-      }
-      const details = {
-        answer: params.answer,
-        results: params.results.map((result) => ({
-          number: result.number,
-          title: result.title,
-          summary: result.summary,
-          evidence: (result.evidence ?? []).map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
-          ...result.confidence !== undefined ? { confidence: result.confidence } : {}
-        })),
-        sources: evidenceRefs.flatMap((entry) => {
-          const [primary] = entry.refs;
-          return primary === undefined ? [] : [{ number: entry.number, source: primary.source }];
-        }),
-        evidenceRefs
-      };
-      capture(details);
-      return {
-        content: [
-          {
-            type: "text",
-            text: "Fast answer delivered to the user. Stop now; a deeper verification pass follows separately."
-          }
-        ],
-        details
-      };
-    }
-  };
+function readAccessToken(body) {
+  if (typeof body !== "object" || body === null)
+    return;
+  const value = body.access_token;
+  return typeof value === "string" && value !== "" ? value : undefined;
 }
-var EMIT_FAST_ANSWER_TOOL_NAME = "emit_fast_answer", fastAnswerSchema;
-var init_fast_answer_tool = __esm(() => {
-  fastAnswerSchema = Type6.Object({
-    answer: Type6.String({
-      description: `Complete, self-contained first answer for the caller in at most 5 bullet points (plus optional explanation), produced immediately from baseline retrieval evidence. Reference results by bracketed number (e.g. [1], [2]) without file paths or raw chunk text, except the image-embed exception below. ${ANSWER_CITATION_RULE} ${ANSWER_IMAGE_EMBED_RULE}`
-    }),
-    results: Type6.Array(Type6.Object({
-      number: Type6.Integer({ description: "1-based result number" }),
-      title: Type6.String({ description: "Short name of the knowledge unit" }),
-      summary: Type6.String({ description: "Key insight backing the first answer" }),
-      evidence: Type6.Optional(Type6.Array(Type6.Object({
-        excerpt: Type6.String({ description: "Supporting excerpt" }),
-        lineNumber: Type6.Optional(Type6.Integer({ description: "Line number of the excerpt, if known" }))
-      }))),
-      confidence: Type6.Optional(Type6.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 })),
-      refs: Type6.Optional(Type6.Array(Type6.String(), {
-        description: "Evidence ids from the baseline evidence that support this result (e.g. e3). The source path is attached for you. Omit only when no baseline evidence backs the result."
-      }))
-    }), { description: "Numbered knowledge units backing the first answer." })
+function readEmail(body) {
+  if (typeof body !== "object" || body === null)
+    return;
+  const value = body.email;
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+var init_token = __esm(() => {
+  init_config();
+  init_errors3();
+});
+
+// src/cloud/oauth-login.ts
+function refreshAutoragCredentials(credentials) {
+  return credentials;
+}
+async function loginAutorag(callbacks, options) {
+  const { verifier, challenge } = createPkcePair();
+  const state = createState();
+  const server = await startCallbackServer({
+    state,
+    timeoutMs: options.timeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS,
+    signal: callbacks.signal
   });
+  try {
+    callbacks.onAuth({
+      url: buildAuthorizeUrl({
+        baseUrl: options.baseUrl,
+        redirectUri: server.redirectUri,
+        state,
+        codeChallenge: challenge
+      }),
+      instructions: `Waiting for the AutoRAG sign-in callback on ${server.redirectUri}. If the browser cannot reach this machine, paste the final redirect URL or the code instead.`
+    });
+    callbacks.onProgress?.(`Listening for the AutoRAG sign-in callback on ${server.redirectUri}`);
+    const outcome = await Promise.race([
+      server.waitForCallback().then((params) => ({ params })),
+      callbacks.onPrompt({
+        message: "Complete the AutoRAG sign-in in your browser, or paste the final redirect URL / authorization code here:",
+        placeholder: server.redirectUri,
+        allowEmpty: true
+      }).then((value) => ({ value }))
+    ]);
+    const parsed = "params" in outcome ? parseCallbackQuery(outcome.params) : parseCallbackInput(outcome.value);
+    const { code } = requireAuthorizationCode(parsed, state);
+    const token = await exchangeCodeForToken({
+      baseUrl: options.baseUrl,
+      code,
+      codeVerifier: verifier,
+      redirectUri: server.redirectUri,
+      signal: callbacks.signal,
+      fetchImpl: options.fetchImpl
+    });
+    return {
+      access: token.accessToken,
+      refresh: "",
+      expires: Number.MAX_SAFE_INTEGER,
+      ...token.email !== undefined ? { email: token.email } : {}
+    };
+  } finally {
+    server.close();
+  }
+}
+var init_oauth_login = __esm(() => {
+  init_authorize();
+  init_callback();
+  init_callback_server();
+  init_pkce();
+  init_token();
 });
 
-// src/agent/fsearch-search-tool.ts
-import { Type as Type7 } from "typebox";
-function createFSearchSearchTool(provider) {
+// src/cloud/provider.ts
+async function refreshAutoragModels(context, endpoints) {
+  const stored = modelsFromStore(context.stored);
+  const apiKey = resolveCredentialKey(context.credential);
+  if (!context.allowNetwork || apiKey === undefined)
+    return stored;
+  let models;
+  try {
+    models = await fetchModels({ baseUrl: endpoints.baseUrl, apiKey, signal: context.signal });
+  } catch {
+    return stored;
+  }
+  if (models.length === 0)
+    return stored;
+  try {
+    await context.publish({ persist: buildStoreEntry(models, PROVIDER_ID, endpoints.apiBaseUrl) });
+  } catch {}
+  return models;
+}
+function createAutoRAGProviderConfig(env = process.env) {
+  const baseUrl = resolveBaseUrl(env);
+  const endpoints = { baseUrl, apiBaseUrl: `${baseUrl}${API_PATH}` };
   return {
-    name: FSEARCH_SEARCH_TOOL_NAME,
-    label: "FSearch Search",
-    description: "Instantly find files and folders by name, extension, path, size, or modified date across the configured search folders using fsearch-cli/FSearch (macOS/Linux), falling back to a slow filesystem walk when fsearch-cli is not installed. Returns absolute paths; read file contents with bash.",
-    parameters: fsearchSearchSchema,
-    async execute(_toolCallId, params) {
-      const query = params.query.trim();
-      if (query.length === 0) {
-        return {
-          content: [{ type: "text", text: "FSearch query was empty; nothing searched." }],
-          details: { method: FSEARCH_SEARCH_TOOL_NAME, resultCount: 0, sources: [], results: [] }
-        };
-      }
-      const request = {
-        ...params,
-        query,
-        maxResults: Math.min(params.maxResults ?? DEFAULT_MAX_RESULTS4, MAX_RESULTS_CAP3)
-      };
-      const result = await provider.searchFsearch(request);
-      if (!result.ok) {
-        return {
-          content: [{ type: "text", text: `FSearch ${result.reason}: ${result.message}` }],
-          details: { method: FSEARCH_SEARCH_TOOL_NAME, resultCount: 0, sources: [], results: [] }
-        };
-      }
-      const lines = result.results.map((entry, index) => {
-        const parts = [`[${index + 1}] ${entry.type} ${entry.path}`];
-        if (entry.size !== undefined)
-          parts.push(`size=${entry.size}`);
-        if (entry.dateModified !== undefined)
-          parts.push(`modified=${entry.dateModified}`);
-        return parts.join(" ");
-      });
-      const backendLabel = result.backend === "walk" ? "FSearch slow filesystem walk (fsearch-cli unavailable)" : "FSearch";
-      const limitNote = result.backend === "fsearch-cli" && (result.total ?? 0) > lines.length && lines.length === request.maxResults ? ` of ${result.total} total (limit reached; narrow the query or page with offset)` : "";
-      const noteSuffix = result.note !== undefined ? `
-${result.note}` : "";
-      const text = lines.length === 0 ? `${backendLabel} found no files or folders matching: ${query}${noteSuffix}` : `${backendLabel} found ${lines.length} item(s)${limitNote}:
-${lines.join(`
-`)}${noteSuffix}`;
-      return {
-        content: [{ type: "text", text }],
-        details: {
-          method: FSEARCH_SEARCH_TOOL_NAME,
-          resultCount: result.results.length,
-          sources: result.results.map((entry) => entry.path),
-          results: result.results.map((entry, index) => ({ source: entry.path, excerpt: lines[index] }))
-        }
-      };
-    }
+    name: PROVIDER_NAME,
+    baseUrl: endpoints.apiBaseUrl,
+    api: "openai-responses",
+    apiKey: API_KEY_CONFIG_VALUE,
+    oauth: {
+      name: PROVIDER_NAME,
+      login: (callbacks) => loginAutorag(callbacks, { baseUrl }),
+      refreshToken: async (credentials) => refreshAutoragCredentials(credentials),
+      getApiKey: (credentials) => credentials.access
+    },
+    refreshModels: (context) => refreshAutoragModels(context, endpoints)
   };
 }
-var FSEARCH_SEARCH_TOOL_NAME = "fsearch_search", MAX_RESULTS_CAP3 = 1000, DEFAULT_MAX_RESULTS4 = 100, fsearchSearchSchema;
-var init_fsearch_search_tool = __esm(() => {
-  fsearchSearchSchema = Type7.Object({
-    query: Type7.String({
-      description: 'FSearch query syntax over file and folder names: space = AND, OR keyword = OR (never the pipe |), ! = NOT, "quoted phrase", wildcards (*.pdf), ext:pdf;docx, size:>10mb, path:<fragment>, case:, regex:. When the slow-walk fallback answers (fsearch-cli not installed), only substring/regex name matching applies.'
-    }),
-    regex: Type7.Optional(Type7.Boolean({ description: "Treat query as a regular expression." })),
-    matchCase: Type7.Optional(Type7.Boolean()),
-    matchPath: Type7.Optional(Type7.Boolean({ description: "Match against the full path instead of the name." })),
-    kind: Type7.Optional(Type7.Union([Type7.Literal("files"), Type7.Literal("folders")])),
-    path: Type7.Optional(Type7.String({ description: "Absolute folder to search within." })),
-    sort: Type7.Optional(Type7.Union([
-      Type7.Literal("name-ascending"),
-      Type7.Literal("name-descending"),
-      Type7.Literal("path-ascending"),
-      Type7.Literal("path-descending"),
-      Type7.Literal("size-ascending"),
-      Type7.Literal("size-descending"),
-      Type7.Literal("date-modified-ascending"),
-      Type7.Literal("date-modified-descending")
-    ])),
-    offset: Type7.Optional(Type7.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
-    maxResults: Type7.Optional(Type7.Integer({
-      minimum: 1,
-      description: `Maximum results (default ${DEFAULT_MAX_RESULTS4}, cap ${MAX_RESULTS_CAP3}).`
-    }))
-  });
+async function registerAutoRAGProvider(runtime, env = process.env) {
+  runtime.registerProvider(PROVIDER_ID, createAutoRAGProviderConfig(env));
+  await runtime.refresh({ allowNetwork: false, providers: [PROVIDER_ID] });
+}
+var init_provider = __esm(() => {
+  init_config();
+  init_models();
+  init_oauth_login();
 });
 
 // src/agent/pi-session.ts
@@ -9201,6 +9749,7 @@ async function createAutoRAGPiSession(options) {
     authPath: join21(agentDir, "auth.json"),
     modelsPath: join21(agentDir, "models.json")
   });
+  await registerAutoRAGProvider(modelRuntime);
   await configureModelRuntime(modelRuntime, options.model, options.apiKey, options.providerApiKeys);
   const customTools = [...options.customTools];
   const extensionToolNames = [...options.extensionToolNames ?? []];
@@ -9250,6 +9799,7 @@ async function createAutoRAGPiInteractiveRuntime(options) {
     authPath: join21(agentDir, "auth.json"),
     modelsPath: join21(agentDir, "models.json")
   });
+  await registerAutoRAGProvider(modelRuntime);
   await configureModelRuntime(modelRuntime, options.model, options.apiKey, options.providerApiKeys);
   const sessionManager = options.sessionPath ? SessionManager.open(options.sessionPath, options.sessionDir, options.cwd) : SessionManager.create(options.cwd, options.sessionDir);
   const createRuntime = async ({
@@ -9299,12 +9849,13 @@ async function createAutoRAGPiInteractiveRuntime(options) {
 }
 var PI_BUILTIN_TOOL_NAMES, EMBEDDED_AUTH_MARKER = "<autorag-embedded-model>";
 var init_pi_session = __esm(() => {
+  init_provider();
   PI_BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 });
 
 // src/agent/jev-extension.ts
 import { Jev } from "jev-use";
-import { Type as Type8 } from "typebox";
+import { Type as Type6 } from "typebox";
 function createJevJudge(options = {}) {
   let client;
   return async (state, questions, callOptions = {}) => {
@@ -9357,32 +9908,32 @@ var JEV_TOOL_NAME = "jev", OPENROUTER_DEFAULT_MODEL = "typesafe/jev-1.13", BACKE
 var init_jev_extension = __esm(() => {
   init_pi_session();
   BACKEND_DEFAULT_MODEL = { openrouter: OPENROUTER_DEFAULT_MODEL };
-  jevQuestionSchema = Type8.Object({
-    id: Type8.Optional(Type8.String({ description: "Caller-assigned id, echoed back in the verdict" })),
-    type: Type8.Union([Type8.Literal("noul"), Type8.Literal("choice"), Type8.Literal("score")], {
+  jevQuestionSchema = Type6.Object({
+    id: Type6.Optional(Type6.String({ description: "Caller-assigned id, echoed back in the verdict" })),
+    type: Type6.Union([Type6.Literal("noul"), Type6.Literal("choice"), Type6.Literal("score")], {
       description: "noul = P(yes), choice = pick one option, score = ordered level index"
     }),
-    question: Type8.String({
+    question: Type6.String({
       minLength: 1,
       description: "One narrow question about the state. Jev answers exactly this."
     }),
-    options: Type8.Optional(Type8.Union([Type8.Array(Type8.String()), Type8.Record(Type8.String(), Type8.String())], {
+    options: Type6.Optional(Type6.Union([Type6.Array(Type6.String()), Type6.Record(Type6.String(), Type6.String())], {
       description: "choice only: at least two option labels (or label -> meaning)"
     })),
-    levels: Type8.Optional(Type8.Array(Type8.String(), {
+    levels: Type6.Optional(Type6.Array(Type6.String(), {
       description: "score only: at least two ordered level descriptions; the answer indexes into them"
     })),
-    criteria: Type8.Optional(Type8.Object({ true: Type8.String(), false: Type8.String() }, { description: "noul only: what yes and no mean, to sharpen calibration" }))
+    criteria: Type6.Optional(Type6.Object({ true: Type6.String(), false: Type6.String() }, { description: "noul only: what yes and no mean, to sharpen calibration" }))
   });
-  jevParameters = Type8.Object({
-    state: Type8.Unknown({
+  jevParameters = Type6.Object({
+    state: Type6.Unknown({
       description: "Text, JSON object, or JSON array Jev should judge. Keep it small and self-contained."
     }),
-    questions: Type8.Array(jevQuestionSchema, {
+    questions: Type6.Array(jevQuestionSchema, {
       minItems: 1,
       description: "Named questions, all evaluated against the same state in one batched request."
     }),
-    confidence_threshold: Type8.Optional(Type8.Number({
+    confidence_threshold: Type6.Optional(Type6.Number({
       minimum: 0,
       maximum: 1,
       description: "Escalate any verdict below this confidence; omitted uses jev-use's per-source defaults"
@@ -9391,7 +9942,7 @@ var init_jev_extension = __esm(() => {
 });
 
 // src/agent/jikji-find-tool.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type7 } from "typebox";
 function createJikjiFindTool(provider, ledger = new EvidenceLedger) {
   return {
     name: JIKJI_FIND_TOOL_NAME,
@@ -9522,10 +10073,10 @@ function formatDirective(policy) {
 var JIKJI_FIND_TOOL_NAME = "jikji_find", jikjiFindSchema;
 var init_jikji_find_tool = __esm(() => {
   init_evidence_ledger();
-  jikjiFindSchema = Type9.Object({
-    query: Type9.String({ description: "Query for Jikji local file discovery." }),
-    topK: Type9.Optional(Type9.Integer({ description: "Maximum number of answer paths / candidates to return." })),
-    first: Type9.Optional(Type9.Boolean({ description: "Return only the first/best answer." }))
+  jikjiFindSchema = Type7.Object({
+    query: Type7.String({ description: "Query for Jikji local file discovery." }),
+    topK: Type7.Optional(Type7.Integer({ description: "Maximum number of answer paths / candidates to return." })),
+    first: Type7.Optional(Type7.Boolean({ description: "Return only the first/best answer." }))
   });
 });
 
@@ -10494,57 +11045,57 @@ var init_policy = __esm(() => {
 });
 
 // src/p2p/wire.ts
-import { Type as Type10 } from "typebox";
+import { Type as Type8 } from "typebox";
 var PeerRefusalCodeSchema, PeerDiagnosticSchema, PeerFileEntrySchema, PeerResultEntrySchema, PeerQueryRequestSchema, PeerQueryResponseSchema;
 var init_wire = __esm(() => {
-  PeerRefusalCodeSchema = Type10.Union([
-    Type10.Literal("auth-error"),
-    Type10.Literal("replay-rejected"),
-    Type10.Literal("rate-limited"),
-    Type10.Literal("injection-detected"),
-    Type10.Literal("policy-denied"),
-    Type10.Literal("queue-full"),
-    Type10.Literal("internal-error")
+  PeerRefusalCodeSchema = Type8.Union([
+    Type8.Literal("auth-error"),
+    Type8.Literal("replay-rejected"),
+    Type8.Literal("rate-limited"),
+    Type8.Literal("injection-detected"),
+    Type8.Literal("policy-denied"),
+    Type8.Literal("queue-full"),
+    Type8.Literal("internal-error")
   ]);
-  PeerDiagnosticSchema = Type10.Object({
-    code: Type10.String({ minLength: 1, description: "Diagnostic or refusal code" }),
-    message: Type10.String({ description: "Human-readable diagnostic message" })
+  PeerDiagnosticSchema = Type8.Object({
+    code: Type8.String({ minLength: 1, description: "Diagnostic or refusal code" }),
+    message: Type8.String({ description: "Human-readable diagnostic message" })
   });
-  PeerFileEntrySchema = Type10.Object({
-    source: Type10.String({
+  PeerFileEntrySchema = Type8.Object({
+    source: Type8.String({
       description: "Canonical retrieval source identifier"
     }),
-    contentBase64: Type10.String({ description: "Base64-encoded file content" }),
-    redacted: Type10.Boolean({ description: "Whether the content was PII-redacted" })
+    contentBase64: Type8.String({ description: "Base64-encoded file content" }),
+    redacted: Type8.Boolean({ description: "Whether the content was PII-redacted" })
   });
-  PeerResultEntrySchema = Type10.Object({
-    number: Type10.Integer({ minimum: 1, description: "1-based result number" }),
-    title: Type10.String({ minLength: 1, description: "Short title of the result" }),
-    summary: Type10.String({ description: "Key insight summary" }),
-    source: Type10.String({
+  PeerResultEntrySchema = Type8.Object({
+    number: Type8.Integer({ minimum: 1, description: "1-based result number" }),
+    title: Type8.String({ minLength: 1, description: "Short title of the result" }),
+    summary: Type8.String({ description: "Key insight summary" }),
+    source: Type8.String({
       description: "Canonical retrieval source identifier"
     }),
-    excerpt: Type10.String({ description: "Supporting excerpt" })
+    excerpt: Type8.String({ description: "Supporting excerpt" })
   });
-  PeerQueryRequestSchema = Type10.Object({
-    v: Type10.Literal(1, { description: "Protocol version" }),
-    query: Type10.String({ minLength: 1, maxLength: 4096, description: "Search query (max 4096 chars)" }),
-    topK: Type10.Optional(Type10.Integer({ minimum: 1, maximum: 20, description: "Max results to return (max 20)" })),
-    scope: Type10.Optional(Type10.String({ description: "Optional search scope hint" }))
+  PeerQueryRequestSchema = Type8.Object({
+    v: Type8.Literal(1, { description: "Protocol version" }),
+    query: Type8.String({ minLength: 1, maxLength: 4096, description: "Search query (max 4096 chars)" }),
+    topK: Type8.Optional(Type8.Integer({ minimum: 1, maximum: 20, description: "Max results to return (max 20)" })),
+    scope: Type8.Optional(Type8.String({ description: "Optional search scope hint" }))
   });
-  PeerQueryResponseSchema = Type10.Object({
-    v: Type10.Literal(1, { description: "Protocol version" }),
-    status: Type10.Union([Type10.Literal("ok"), Type10.Literal("rejected")], {
+  PeerQueryResponseSchema = Type8.Object({
+    v: Type8.Literal(1, { description: "Protocol version" }),
+    status: Type8.Union([Type8.Literal("ok"), Type8.Literal("rejected")], {
       description: "Response status"
     }),
-    answer: Type10.String({ description: "Curated answer text" }),
-    results: Type10.Array(PeerResultEntrySchema, {
+    answer: Type8.String({ description: "Curated answer text" }),
+    results: Type8.Array(PeerResultEntrySchema, {
       description: "Curated result entries with opaque source ids"
     }),
-    files: Type10.Array(PeerFileEntrySchema, {
+    files: Type8.Array(PeerFileEntrySchema, {
       description: "Attached original files with opaque source ids"
     }),
-    diagnostics: Type10.Array(PeerDiagnosticSchema, {
+    diagnostics: Type8.Array(PeerDiagnosticSchema, {
       description: "Diagnostic messages (degraded-mode, rejection reasons, etc.)"
     })
   });
@@ -10791,7 +11342,7 @@ var init_simplex_query_store = __esm(() => {
 // src/p2p/simplex-server.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join26 } from "node:path";
-import { Type as Type11 } from "typebox";
+import { Type as Type9 } from "typebox";
 import { Value as Value2 } from "typebox/value";
 function targetTokens(value) {
   return new Set((value.toLocaleLowerCase().match(TARGET_TOKEN_PATTERN) ?? []).filter((token) => token.length > 1));
@@ -11105,11 +11656,11 @@ var init_simplex_server = __esm(() => {
     shareBytes: false,
     redact: true
   };
-  SimplexWireEnvelopeSchema = Type11.Object({
-    v: Type11.Literal(1, { description: "Envelope version" }),
-    kind: Type11.Union([Type11.Literal("query"), Type11.Literal("response")], { description: "Payload kind" }),
-    id: Type11.String({ minLength: 1, maxLength: 128, description: "Correlation id" }),
-    payload: Type11.Unknown({ description: "PeerQueryRequest or PeerQueryResponse" })
+  SimplexWireEnvelopeSchema = Type9.Object({
+    v: Type9.Literal(1, { description: "Envelope version" }),
+    kind: Type9.Union([Type9.Literal("query"), Type9.Literal("response")], { description: "Payload kind" }),
+    id: Type9.String({ minLength: 1, maxLength: 128, description: "Correlation id" }),
+    payload: Type9.Unknown({ description: "PeerQueryRequest or PeerQueryResponse" })
   });
   TARGET_TOKEN_PATTERN = /[\p{L}\p{N}]+/gu;
   PEERS_DIR = join26(".autorag", "p2p");
@@ -11122,7 +11673,7 @@ var init_simplex_server = __esm(() => {
 });
 
 // src/agent/peer-target-tool.ts
-import { Type as Type12 } from "typebox";
+import { Type as Type10 } from "typebox";
 function createRecommendPeerTargetsTool(workspacePath) {
   return {
     name: RECOMMEND_PEER_TARGETS_TOOL_NAME,
@@ -11155,8 +11706,8 @@ function createRecommendPeerTargetsTool(workspacePath) {
 var RECOMMEND_PEER_TARGETS_TOOL_NAME = "recommend_peer_targets", recommendPeerTargetsSchema;
 var init_peer_target_tool = __esm(() => {
   init_simplex_server();
-  recommendPeerTargetsSchema = Type12.Object({
-    query: Type12.String({ description: "Question or topic to match against local peer personas." })
+  recommendPeerTargetsSchema = Type10.Object({
+    query: Type10.String({ description: "Question or topic to match against local peer personas." })
   });
 });
 
@@ -11232,7 +11783,7 @@ var MAX_DECOMPOSED_QUERIES = 5;
 var init_query_decomposition = () => {};
 
 // src/agent/query-peer-tool.ts
-import { Type as Type13 } from "typebox";
+import { Type as Type11 } from "typebox";
 function failure(alias, message) {
   const details = { method: "query_peer_agent", ok: false, alias, message };
   return { content: [{ type: "text", text: message }], details };
@@ -11347,11 +11898,11 @@ var init_query_peer_tool = __esm(() => {
   init_simplex_query_store();
   init_simplex_server();
   init_evidence_ledger();
-  queryPeerAgentSchema = Type13.Object({
-    alias: Type13.String({ minLength: 1 }),
-    query: Type13.String({ minLength: 1, maxLength: 4096 }),
-    topK: Type13.Optional(Type13.Integer({ minimum: 1, maximum: 20 })),
-    scope: Type13.Optional(Type13.String())
+  queryPeerAgentSchema = Type11.Object({
+    alias: Type11.String({ minLength: 1 }),
+    query: Type11.String({ minLength: 1, maxLength: 4096 }),
+    topK: Type11.Optional(Type11.Integer({ minimum: 1, maximum: 20 })),
+    scope: Type11.Optional(Type11.String())
   });
 });
 
@@ -11618,29 +12169,29 @@ function reconcileCitations(answer, results) {
     ]
   };
 }
-function createPreliminarySearchDocumentsResponse(sessionId, query, details, diagnostics = []) {
-  const sourceByNumber = new Map(details.sources.map((entry) => [entry.number, entry.source]));
-  const results = details.results.map((result) => ({
+function toSearchResults(details, sourceByNumber) {
+  return details.results.map((result) => ({
     number: result.number,
     title: result.title,
     summary: result.summary,
     evidence: result.evidence.map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
-    confidence: confidenceFrom(result.confidence ?? 0.5),
+    ...result.confidence !== undefined ? { confidence: confidenceFrom(result.confidence) } : {},
     source: sourceByNumber.get(result.number)
   }));
-  const citations = reconcileCitations(details.answer, results);
+}
+function createPreliminarySearchDocumentsResponse(sessionId, query, details, diagnostics = []) {
+  const sourceByNumber = new Map(details.mapping.map((entry) => [entry.number, entry.source]));
   return {
     sessionId,
     query,
-    results,
-    answer: citations.answer,
+    results: toSearchResults(details, sourceByNumber),
+    answer: details.answer,
     searched: details.results.length,
     warnings: [],
-    diagnostics: [...citations.diagnostics, ...diagnostics]
+    diagnostics: [...diagnostics]
   };
 }
-function createEmptySearchDocumentsResponse(sessionId, query, sessions, diagnostics = []) {
-  sessions.set(sessionId, { query, registry: new Map });
+function createEmptySearchDocumentsResponse(sessionId, query, diagnostics = []) {
   return {
     sessionId,
     query,
@@ -11656,7 +12207,7 @@ function normalizeEntryEvidenceRefs(entry) {
   const derivedRetrieverMix = Array.from(new Set(rawRefs.map((ref) => ref.method)));
   return rawRefs.map((ref) => {
     if (ref.excerpt === undefined && ref.content === undefined) {
-      throw new Error("emit_autorag_results: every evidenceRef must include excerpt or content");
+      throw new Error("results: every evidenceRef must include excerpt or content");
     }
     return normalizeSessionEvidenceRef({
       method: ref.method,
@@ -11677,19 +12228,11 @@ function normalizeEntryEvidenceRefs(entry) {
     });
   });
 }
-function recordStructuredResultsSession(sessionId, query, details, sessions, memory, componentDiagnostics = [], options = {}) {
-  assertResultsMappingOneToOne("emit_autorag_results", details.results, details.mapping);
-  const registry = new Map;
+function recordStructuredResultsSession(sessionId, query, details, memory, componentDiagnostics = [], options = {}) {
+  assertResultsMappingOneToOne("results", details.results, details.mapping);
   const memoryResults = [];
   for (const entry of details.mapping) {
     const evidenceRefs = normalizeEntryEvidenceRefs(entry);
-    registry.set(entry.number, {
-      index: entry.number,
-      content: entry.content,
-      source: entry.source,
-      method: entry.method,
-      evidenceRefs
-    });
     const emittedResult = details.results.find((result) => result.number === entry.number);
     memoryResults.push({
       number: entry.number,
@@ -11698,23 +12241,15 @@ function recordStructuredResultsSession(sessionId, query, details, sessions, mem
       content: entry.content,
       method: entry.method,
       source: entry.source,
-      ...emittedResult !== undefined ? { confidence: confidenceFrom(emittedResult.confidence) } : {},
+      ...emittedResult?.confidence !== undefined ? { confidence: confidenceFrom(emittedResult.confidence) } : {},
       evidenceRefs
     });
   }
-  sessions.set(sessionId, { query, registry });
   if (!options.isolateMemory) {
     memory.recordCuratedResultsSession({ sessionId, query, results: memoryResults });
     memory.save();
   }
-  const results = details.results.map((result) => ({
-    number: result.number,
-    title: result.title,
-    summary: result.summary,
-    evidence: result.evidence.map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
-    confidence: confidenceFrom(result.confidence),
-    source: registry.get(result.number)?.source || undefined
-  }));
+  const results = toSearchResults(details, new Map(details.mapping.map((entry) => [entry.number, entry.source || undefined])));
   const citations = reconcileCitations(details.answer, results);
   const answer = citations.answer;
   const diagnostics = [...citations.diagnostics];
@@ -11744,7 +12279,7 @@ var init_search_documents = __esm(() => {
 });
 
 // src/agent/search-all-tool.ts
-import { Type as Type14 } from "typebox";
+import { Type as Type12 } from "typebox";
 function createSearchAllDocumentsTool(provider, ledger = new EvidenceLedger) {
   return {
     name: SEARCH_ALL_DOCUMENTS_TOOL_NAME,
@@ -11799,17 +12334,17 @@ var SEARCH_ALL_DOCUMENTS_TOOL_NAME = "search_all_documents", searchAllSchema;
 var init_search_all_tool = __esm(() => {
   init_evidence_ledger();
   init_search_documents();
-  searchAllSchema = Type14.Object({
-    query: Type14.String({ description: "Query to search across all configured retrieval methods." }),
-    topK: Type14.Optional(Type14.Integer({
+  searchAllSchema = Type12.Object({
+    query: Type12.String({ description: "Query to search across all configured retrieval methods." }),
+    topK: Type12.Optional(Type12.Integer({
       description: "Upper bound on returned evidence. Omit it to receive every distinct chunk the methods found; set it only when you deliberately want a shorter list."
     })),
-    scope: Type14.Optional(Type14.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
+    scope: Type12.Optional(Type12.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
   });
 });
 
 // src/agent/search-minsync-tool.ts
-import { Type as Type15 } from "typebox";
+import { Type as Type13 } from "typebox";
 function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => scope, ledger = new EvidenceLedger) {
   return {
     name: SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME,
@@ -11859,12 +12394,12 @@ var SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME = "semantic_search_local_docs", searchMin
 var init_search_minsync_tool = __esm(() => {
   init_evidence_ledger();
   init_search_documents();
-  searchMinSyncSchema = Type15.Object({
-    query: Type15.String({
+  searchMinSyncSchema = Type13.Object({
+    query: Type13.String({
       description: "Semantic query to search parsed document mirrors with MinSync vector retrieval."
     }),
-    topK: Type15.Optional(Type15.Integer({ description: "Maximum number of MinSync semantic chunks to return. Defaults to 50." })),
-    scope: Type15.Optional(Type15.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
+    topK: Type13.Optional(Type13.Integer({ description: "Maximum number of MinSync semantic chunks to return. Defaults to 50." })),
+    scope: Type13.Optional(Type13.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
   });
 });
 
@@ -11882,7 +12417,7 @@ function datasourceSearchToolName(datasourceId) {
 }
 
 // src/agent/search-single-datasource-tool.ts
-import { Type as Type16 } from "typebox";
+import { Type as Type14 } from "typebox";
 function createSingleDatasourceSearchTools(provider, specs, ledger = new EvidenceLedger) {
   return specs.map((spec) => createTool(provider, spec, ledger));
 }
@@ -11948,10 +12483,10 @@ var init_search_single_datasource_tool = __esm(() => {
   init_evidence_ledger();
   init_search_documents();
   singleDatasourceToolName = datasourceSearchToolName;
-  searchSingleDatasourceSchema = Type16.Object({
-    query: Type16.String({ description: "Query to search within this datasource connection." }),
-    topK: Type16.Optional(Type16.Integer({ description: "Maximum number of chunks to return. Defaults to 20." })),
-    scope: Type16.Optional(Type16.String({ description: "Optional scope narrowing inside this datasource, e.g. one instance root." }))
+  searchSingleDatasourceSchema = Type14.Object({
+    query: Type14.String({ description: "Query to search within this datasource connection." }),
+    topK: Type14.Optional(Type14.Integer({ description: "Maximum number of chunks to return. Defaults to 20." })),
+    scope: Type14.Optional(Type14.String({ description: "Optional scope narrowing inside this datasource, e.g. one instance root." }))
   });
 });
 
@@ -12036,7 +12571,7 @@ ${input.skill}
 
 ${input.query}
 
-` + `When done, call emit_autorag_results exactly once with: \`answer\` = a short report of what you changed (field: old → new), what you verified and how, ` + `and anything that still needs the user (for example an unset API-key environment variable, by name only); \`results\` = []. ` + `If you changed nothing, say why.`;
+` + `When done, reply with a short report as your final message, with no tool call: what you changed (field: old → new), what you verified and how, ` + `and anything that still needs the user (for example an unset API-key environment variable, by name only). ` + `If you changed nothing, say why.`;
 }
 var SETUP_SKILL_RELATIVE_PATH;
 var init_self_config = __esm(() => {
@@ -12067,7 +12602,6 @@ function buildSystemPrompt(config) {
     toolLine(config, "check_memory", "inspect evidence earlier searches found for similar questions"),
     toolLine(config, "recommend_peer_targets", "recommend local peer personas to ask about a topic without contacting them"),
     toolLine(config, "query_peer_agent", "ask one trusted peer agent over SimpleX"),
-    toolLine(config, "emit_autorag_results", "return the final structured answer with evidence ids for each result"),
     ...config.toolNames.filter((name) => name.startsWith("search_datasource_")).map((name) => `- **${name}**: search only the ${name.slice("search_datasource_".length).replace(/_/g, "-")} datasource connection, spawning no other datasource CLIs`),
     ...config.toolNames.filter((name) => ![
       "bash",
@@ -12083,8 +12617,7 @@ function buildSystemPrompt(config) {
       "jev",
       "check_memory",
       "recommend_peer_targets",
-      "query_peer_agent",
-      "emit_autorag_results"
+      "query_peer_agent"
     ].includes(name) && !name.startsWith("search_datasource_")).map((name) => `- **${name}**: caller-provided tool`)
   ].filter((line) => line !== undefined);
   const manifests = config.manifests.length === 0 ? "" : `
@@ -12148,12 +12681,12 @@ Your job is to retrieve candidates, read the relevant source material directly,
 ## Workflow
 
 Searches follow a progressive, two-phase loop:
-1. **PLAN & FAST ANSWER** — Decide whether the query is answerable from general knowledge or memory. When baseline retrieval evidence is provided, produce and emit a complete, self-contained immediate first answer via \`emit_fast_answer\` right away from that evidence without calling tools or waiting.
+1. **PLAN & FAST ANSWER** — Decide whether the query is answerable from general knowledge or memory. When baseline retrieval evidence is provided, write a complete, self-contained immediate first answer from that evidence as your reply, right away, without calling tools or waiting.
 2. **EXPLORE & RETRIEVE** — Immediately following the fast answer, begin deeper exploration: ${discovery ? `use ${discovery} actively to locate relevant files and folders, and ` : ""}fan out across MinSync lexical/vector/hybrid retrieval, combined retrieval, and datasource search to expand candidates and fill evidence gaps.
 3. **READ & VERIFY** — Use \`bash\` to open and verify relevant local files directly when needed, and in local sessions to organize files when the user asks (see File Organization); rely on Jikji and retrieval rather than blind directory browsing.
 4. **JUDGE & RESOLVE** — Evaluate relevance, sufficiency, conflicts, and temporal context. When search results or evidence contain conflicting information, treat the freshest (most recent) information as authoritative and correct.
 5. **CURATE** — Produce concise numbered knowledge units grounded in source evidence.
-6. **FINALIZE** — Call \`emit_autorag_results\` exactly once as the final action.
+6. **FINALIZE** — End with the final answer as a plain reply, with no tool call. Earlier replies that are followed by a tool call are progress notes; only the last reply is the answer.
 
 ## Available Tools
 
@@ -12198,17 +12731,17 @@ ${fsearch}
 ${manifests}
 ## Output Format
 
-Call \`emit_autorag_results\` exactly once with:
-- \`answer\`: the curated answer for the caller following the Answer Guidelines below. When a first answer was already delivered to the caller during this run, include only corrections and newly verified findings — never restate the first answer; otherwise give the complete answer. Reference results by bracketed numbers such as [1] and [2].
-- \`results\`: curated units with number, title, summary, evidence, confidence, and \`refs\`.
-- \`refs\`: for every result, the evidence ids (such as \`e3\`) shown next to the retrieved results that support it; for a local file you opened yourself with \`bash\`, its absolute path. The source, method, and chunk are attached from these ids; never type a path or copy a chunk to describe a source.
+Your answer is your final reply, written as plain text, never as a tool call. Cite evidence inline with the ids the retrieval tools print next to each result:
+- Put the id in square brackets at the end of the sentence it supports, e.g. \`The cap is 28% [e3].\` Use \`[e3][e7]\` or \`[e3, e7]\` for several. Copy ids exactly as printed; never invent one.
+- For a local file you opened yourself with \`bash\`, cite \`[file:<absolute path>]\`.
+- The harness resolves every id to its recorded source, number the citations \`[1]\`, \`[2]\`, … in order of first appearance, and attaches the sources for you. Never type a source path, a chunk, or a citation number yourself.
+- A citation whose id no tool returned in this run is dropped, so cite only ids you saw.
 
 ## Answer Guidelines
 
 - **Complete vs. delta answer**: When no first answer reached the caller, give the complete core answer. When a first answer was already delivered, return only the delta against it — corrections and newly verified findings — and never repeat its unchanged content; if nothing changed, confirm the first answer in one short line.
 - **Bullet-point core answer**: Provide the core answer to the user's question in at most 5 bullet points. If additional explanation or context is necessary, append it after the bullet points.
-- **Direct answer only**: The caller only needs the answer to their question. Never include specific file paths, datasource descriptions, or retrieval mechanics/principles in \`answer\` (source paths are attached to each result from the evidence ids you cite in \`refs\`).
-- **Citation style**: Cite supporting evidence chunks using bracketed numbers only (e.g. [1], [2]). Do not quote raw chunk text or mention source paths directly in \`answer\`.
+- **Direct answer only**: The caller only needs the answer to their question. Never include specific file paths, datasource descriptions, or retrieval mechanics/principles in the answer (source paths are attached to each citation from the evidence ids you cite). Do not quote raw chunk text.
 - ${ANSWER_CITATION_RULE}
 - ${ANSWER_IMAGE_EMBED_RULE} ${ANSWER_IMAGE_DELTA_RULE}
 - **No per-source negative reports**: Never report individual negative findings per source (e.g. "no information found in Slack" or "checked Drive but found nothing"). Simply omit unproductive sources from the answer and focus on what was found or provide a concise overall conclusion.
@@ -12221,7 +12754,7 @@ Call \`emit_autorag_results\` exactly once with:
 - **Curate, don't dump**: return useful knowledge units, not raw search output.
 - **Address intent**: answer the caller's actual need.
 - **Preserve traceability**: cite evidence by the ids retrieval tools show, so source paths and excerpts are attached for you.
-- **Finalize once**: the structured result tool is the final action.
+- **Finalize once**: the last reply, with no tool call, is the final answer.
 `;
 }
 var init_system_prompt = __esm(() => {
@@ -14208,7 +14741,7 @@ var init_render = __esm(() => {
 });
 
 // src/agent/web-fetch-tool.ts
-import { Type as Type17 } from "typebox";
+import { Type as Type15 } from "typebox";
 function truncateHead(output, maxBytes, maxLines) {
   const lines = output.split(`
 `);
@@ -14312,9 +14845,9 @@ var init_web_fetch_tool = __esm(() => {
   init_render();
   init_evidence_ledger();
   FETCH_MAX_OUTPUT_BYTES = 50 * 1024;
-  webFetchSchema = Type17.Object({
-    url: Type17.String({ description: "The http(s) URL to fetch and read." }),
-    raw: Type17.Optional(Type17.Boolean({ description: "Return the raw response body without markdown rendering or formatting." }))
+  webFetchSchema = Type15.Object({
+    url: Type15.String({ description: "The http(s) URL to fetch and read." }),
+    raw: Type15.Optional(Type15.Boolean({ description: "Return the raw response body without markdown rendering or formatting." }))
   });
 });
 
@@ -15273,7 +15806,7 @@ function parseResponse(data) {
     } : {}
   };
 }
-var DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com", API_VERSION = "v1beta", DEFAULT_MODEL = "gemini-3.8-flash", MAX_RESPONSE_BYTES, MAX_ERROR_BYTES, GeminiProvider;
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com", API_VERSION = "v1beta", DEFAULT_MODEL = "gemini-3.8-flash", MAX_RESPONSE_BYTES, MAX_ERROR_BYTES, GeminiProvider;
 var init_gemini = __esm(() => {
   init_model_auth();
   init_query();
@@ -15295,7 +15828,7 @@ var init_gemini = __esm(() => {
       const model = envCredential("GEMINI_SEARCH_MODEL") ?? (credential.source === "injected" ? credential.modelId : undefined) ?? DEFAULT_MODEL;
       const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
       const query = parsed.hasDirectives ? formatQuery(parsed, GOOGLE_QUERY_SYNTAX) : params.query;
-      const baseUrl = (credential.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+      const baseUrl = (credential.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
       const fetchImpl = params.fetch ?? fetch;
       const response = await fetchImpl(`${baseUrl}/${API_VERSION}/models/${model}:generateContent`, {
         method: "POST",
@@ -15440,7 +15973,7 @@ function parseResponse2(response) {
     ...response.id !== undefined ? { requestId: response.id } : {}
   };
 }
-var DEFAULT_BASE_URL2 = "https://api.anthropic.com", DEFAULT_MODEL2 = "claude-haiku-5-5", DEFAULT_MAX_TOKENS = 4096, MAX_RESPONSE_BYTES2, MAX_ERROR_BYTES2, WEB_SEARCH_TOOL_TYPE = "web_search_20250305", ANTHROPIC_QUERY_SYNTAX, AnthropicProvider;
+var DEFAULT_BASE_URL3 = "https://api.anthropic.com", DEFAULT_MODEL2 = "claude-haiku-5-5", DEFAULT_MAX_TOKENS2 = 4096, MAX_RESPONSE_BYTES2, MAX_ERROR_BYTES2, WEB_SEARCH_TOOL_TYPE = "web_search_20250305", ANTHROPIC_QUERY_SYNTAX, AnthropicProvider;
 var init_anthropic = __esm(() => {
   init_model_auth();
   init_query();
@@ -15471,7 +16004,7 @@ var init_anthropic = __esm(() => {
       const model = envCredential("ANTHROPIC_SEARCH_MODEL") ?? (credential.source === "injected" ? credential.modelId : undefined) ?? DEFAULT_MODEL2;
       const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
       const plan = planQuery(params.query, parsed);
-      const baseUrl = (credential.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
+      const baseUrl = (credential.baseUrl ?? DEFAULT_BASE_URL3).replace(/\/+$/, "");
       const fetchImpl = params.fetch ?? fetch;
       const response = await fetchImpl(`${baseUrl}/v1/messages?beta=true`, {
         method: "POST",
@@ -15483,7 +16016,7 @@ var init_anthropic = __esm(() => {
         },
         body: JSON.stringify({
           model,
-          max_tokens: params.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+          max_tokens: params.maxOutputTokens ?? DEFAULT_MAX_TOKENS2,
           ...params.systemPrompt ? { system: params.systemPrompt } : {},
           messages: [{ role: "user", content: plan.query }],
           tools: [
@@ -17566,7 +18099,7 @@ async function searchPublicWeb(params, deadlines = {}) {
 }
 var PUBLIC_ENGINE_IDS, DEFAULT_NUM_RESULTS8 = 15, MAX_NUM_RESULTS8 = 30, SOFT_DEADLINE_MS = 5000, HARD_DEADLINE_MS = 30000, PublicWebProvider;
 var init_public = __esm(() => {
-  init_provider();
+  init_provider2();
   init_types3();
   init_utils();
   PUBLIC_ENGINE_IDS = [
@@ -17640,7 +18173,7 @@ function resolveProviderCandidates(routing = {}) {
   return candidates;
 }
 var PROVIDER_META, instanceCache;
-var init_provider = __esm(() => {
+var init_provider2 = __esm(() => {
   init_types3();
   init_types3();
   PROVIDER_META = {
@@ -17826,15 +18359,15 @@ async function executeWebSearch(params, options = {}) {
 }
 var TOTAL_TIMEOUT_MULTIPLIER = 2;
 var init_search = __esm(() => {
-  init_provider();
+  init_provider2();
   init_query();
   init_types3();
-  init_provider();
+  init_provider2();
   init_types3();
 });
 
 // src/agent/web-search-tool.ts
-import { Type as Type18 } from "typebox";
+import { Type as Type16 } from "typebox";
 function createWebSearchTool(options = {}, ledger = new EvidenceLedger) {
   return {
     name: WEB_SEARCH_TOOL_NAME,
@@ -17910,15 +18443,15 @@ var WEB_SEARCH_TOOL_NAME = "web_search", webSearchSchema;
 var init_web_search_tool = __esm(() => {
   init_search();
   init_evidence_ledger();
-  webSearchSchema = Type18.Object({
-    query: Type18.String({
+  webSearchSchema = Type16.Object({
+    query: Type16.String({
       description: 'Search query. Supports Google-style directives: site:/-site:, after:/before: (YYYY-MM-DD), inurl:, intitle:, filetype:, "exact phrase", -term, OR.'
     }),
-    recency: Type18.Optional(Type18.Union([Type18.Literal("day"), Type18.Literal("week"), Type18.Literal("month"), Type18.Literal("year")], {
+    recency: Type16.Optional(Type16.Union([Type16.Literal("day"), Type16.Literal("week"), Type16.Literal("month"), Type16.Literal("year")], {
       description: "Optional recency window for results (pure time filter)."
     })),
-    limit: Type18.Optional(Type18.Integer({ description: "Maximum number of results to return." })),
-    num_search_results: Type18.Optional(Type18.Integer({ description: "Alias for limit (result count hint)." }))
+    limit: Type16.Optional(Type16.Integer({ description: "Maximum number of results to return." })),
+    num_search_results: Type16.Optional(Type16.Integer({ description: "Alias for limit (result count hint)." }))
   });
 });
 
@@ -17965,10 +18498,7 @@ class AutoRAGAgent {
   runLogger;
   lastQuery;
   lastSessionId;
-  sessions = new Map;
   activeRun = false;
-  resultCapture;
-  interactiveFastAnswerCallback;
   modelNativeSearchAuth;
   retrievalTrace = [];
   evidenceLedger = new EvidenceLedger;
@@ -18130,10 +18660,6 @@ class AutoRAGAgent {
     const searchMinSyncTool = createSearchMinSyncDocumentsTool(() => this.remoteFilteredRetrievalMethod(this.minSyncMethod), (scope) => this.resolveRetrievalScope(scope), this.evidenceLedger);
     const searchAllTool = createSearchAllDocumentsTool(this, this.evidenceLedger);
     const loadDatasourceSkillTool = createLoadDatasourceSkillTool(this);
-    const emitResultsTool = createEmitResultsTool((details) => this.resultCapture?.(details), {
-      ledger: this.evidenceLedger,
-      allowLocalFiles: !this.remoteSession
-    });
     const scanDuplicateDocumentsTool = this.dupeyOptions === false ? undefined : createScanDuplicateDocumentsTool(this);
     this.jevJudge = options.jev === undefined || options.jev === false || this.remoteSession ? undefined : createJevJudge(options.jev);
     this.jevExtension = this.jevJudge === undefined ? undefined : createJevExtension(this.jevJudge);
@@ -18168,8 +18694,6 @@ class AutoRAGAgent {
       "check_memory",
       ...singleDatasourceTools.map((tool) => tool.name),
       LOAD_DATASOURCE_SKILL_TOOL_NAME,
-      EMIT_AUTORAG_RESULTS_TOOL_NAME,
-      EMIT_FAST_ANSWER_TOOL_NAME,
       SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME,
       SEARCH_ALL_DOCUMENTS_TOOL_NAME,
       JIKJI_FIND_TOOL_NAME,
@@ -18200,7 +18724,6 @@ class AutoRAGAgent {
       loadDatasourceSkillTool,
       ...webSearchTool !== undefined ? [webSearchTool] : [],
       ...webFetchTool !== undefined ? [webFetchTool] : [],
-      emitResultsTool,
       ...scanDuplicateDocumentsTool !== undefined ? [scanDuplicateDocumentsTool] : [],
       ...jikjiFindTool !== undefined ? [jikjiFindTool] : [],
       ...everythingSearchTool !== undefined ? [everythingSearchTool] : [],
@@ -18347,12 +18870,11 @@ ${context.text}
         source: "memory"
       };
     }
-    const registry = this.sessions.get(sessionId)?.registry;
     const resultByNumber = new Map(details.results.map((result) => [result.number, result]));
     const units = [];
     for (const entry of details.mapping) {
       const result = resultByNumber.get(entry.number);
-      const refs = registry?.get(entry.number)?.evidenceRefs ?? [];
+      const refs = normalizeEntryEvidenceRefs(entry);
       if (result === undefined || refs.length === 0)
         continue;
       for (const ref of refs) {
@@ -18433,7 +18955,7 @@ ${context.text}
       providerApiKeys: { [local.provider]: local.apiKey }
     };
   }
-  async createSearchSession(resolved, systemPrompt, extraTools = []) {
+  async createSearchSession(resolved, systemPrompt) {
     if (this.boundPiRuntime !== undefined) {
       const session = this.boundPiRuntime.session;
       return {
@@ -18453,10 +18975,7 @@ ${context.text}
       apiKey: resolved.apiKey,
       providerApiKeys: resolved.providerApiKeys,
       getSystemPrompt: () => systemPrompt,
-      customTools: [
-        ...this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
-        ...extraTools
-      ],
+      customTools: this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
       remoteSession: this.remoteSession,
       contextTransform: (messages) => this.withMemoryContext(messages),
       ...this.jevExtension !== undefined ? { extensionFactories: [this.jevExtension], extensionToolNames: [JEV_TOOL_NAME] } : {}
@@ -18537,19 +19056,12 @@ ${context.text}
         modelId: this.boundPiRuntime?.session.model?.id ?? resolved?.model.id
       })),
       contextTransform: (messages) => this.withMemoryContext(messages),
-      customTools: [
-        ...this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
-        createEmitFastAnswerTool((details) => this.interactiveFastAnswerCallback?.(details), {
-          ledger: this.evidenceLedger
-        })
-      ],
+      customTools: this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
       onQuery: (query, pi) => this.runInteractivePiQuery(query, pi),
-      inactiveToolNames: [EMIT_FAST_ANSWER_TOOL_NAME],
       ...this.jevExtension !== undefined ? { extensionFactories: [this.jevExtension], extensionToolNames: [JEV_TOOL_NAME] } : {},
       ...this.updateNotice === undefined ? {} : { updateNotice: this.updateNotice }
     });
     this.boundPiRuntime = runtime.runtime;
-    runtime.runtime.session.setActiveToolsByName(runtime.runtime.session.getActiveToolNames().filter((name) => name !== EMIT_FAST_ANSWER_TOOL_NAME));
     const dispose = runtime.dispose;
     return {
       ...runtime,
@@ -18560,17 +19072,14 @@ ${context.text}
       }
     };
   }
+  deriveAnswer(text) {
+    const derived = deriveResultsFromAnswer(text, this.evidenceLedger, { allowLocalFiles: !this.remoteSession });
+    this.routingDiagnostics.push(...derived.diagnostics);
+    return derived.details;
+  }
   async runInteractivePiQuery(query, pi) {
     pi.setSessionName(query.slice(0, 80));
-    for await (const event of this.searchDocumentsStream(query)) {
-      const text = event.type === "progress" ? event.text : event.response.answer;
-      pi.sendMessage({
-        customType: `autorag.${event.type}`,
-        content: [{ type: "text", text }],
-        display: true,
-        details: event
-      }, { triggerTurn: false });
-    }
+    for await (const _event of this.searchDocumentsStream(query)) {}
   }
   abort() {
     this.activeSession?.abort();
@@ -18601,11 +19110,6 @@ ${context.text}
       this.refreshing = false;
     }
   }
-  getResultRegistry(sessionId) {
-    const sid = sessionId ?? this.lastSessionId;
-    const session = sid ? this.sessions.get(sid) : undefined;
-    return session?.registry ?? new Map;
-  }
   async searchDocuments(query, options = {}) {
     if (this.activeRun) {
       throw new Error("AutoRAG agent is busy; await the in-flight searchDocuments() call before starting another");
@@ -18617,7 +19121,7 @@ ${context.text}
     if (trimmedQuery.length === 0) {
       this.lastQuery = trimmedQuery;
       this.lastSessionId = sessionId;
-      return createEmptySearchDocumentsResponse(sessionId, trimmedQuery, this.sessions, this.startupDiagnostics);
+      return createEmptySearchDocumentsResponse(sessionId, trimmedQuery, this.startupDiagnostics);
     }
     options = this.normalizeRetrievalOptions(options);
     if (this.remoteSession && options.observedSources !== undefined)
@@ -18653,11 +19157,7 @@ ${context.text}
         publishPreliminary(details);
     };
     let session;
-    this.interactiveFastAnswerCallback = emitPreliminary;
     let unsubscribers = [];
-    this.resultCapture = (details) => {
-      captured = details;
-    };
     let searchStarted = false;
     try {
       const resolved = await this.resolveSessionModel();
@@ -18675,7 +19175,7 @@ ${context.text}
         model: resolved.model.id
       });
       searchStarted = true;
-      session = await this.createSearchSession(resolved, buildSystemPrompt(this.currentSystemPromptConfig({ modelId: resolved.model.id })), [createEmitFastAnswerTool(emitPreliminary, { ledger: this.evidenceLedger })]);
+      session = await this.createSearchSession(resolved, buildSystemPrompt(this.currentSystemPromptConfig({ modelId: resolved.model.id })));
       this.activeSession = session;
       unsubscribers = this.configureSearchSession(session);
       let timeout;
@@ -18684,45 +19184,36 @@ ${context.text}
         await Promise.race([
           (async () => {
             const plan = await this.planQuery(trimmedQuery, resolved, planAbort.signal);
-            const sessionAgent = session.piSession;
             const activeSession = session;
-            const activateFastPhase = () => {
-              if (sessionAgent !== undefined) {
-                sessionAgent.setThinkingLevel(clampThinkingLevel(resolved.model, this.fastThinkingLevel));
-                sessionAgent.setActiveToolsByName([
-                  ...sessionAgent.getActiveToolNames().filter((name) => name !== EMIT_FAST_ANSWER_TOOL_NAME),
-                  EMIT_FAST_ANSWER_TOOL_NAME
-                ]);
-              } else {
-                activeSession.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.fastThinkingLevel);
-                activeSession.agent.state.tools = [
-                  ...this.tools,
-                  { name: EMIT_FAST_ANSWER_TOOL_NAME }
-                ];
-              }
+            const sessionAgent = activeSession.piSession;
+            const transcript = () => sessionAgent?.messages ?? activeSession.agent.state.messages;
+            const setThinking = (level) => {
+              const clamped = clampThinkingLevel(resolved.model, level);
+              if (sessionAgent !== undefined)
+                sessionAgent.setThinkingLevel(clamped);
+              else
+                activeSession.agent.state.thinkingLevel = clamped;
             };
             if (plan.route === "config" && plan.selfConfigSkill !== undefined && this.selfConfig !== undefined) {
               selfConfigRun = true;
               mkdirSync17(this.workspaceProjectRoot, { recursive: true });
               const previousTools = sessionAgent?.getActiveToolNames();
-              if (sessionAgent !== undefined) {
-                sessionAgent.setThinkingLevel(clampThinkingLevel(resolved.model, this.finalThinkingLevel));
-                sessionAgent.setActiveToolsByName([...PI_BUILTIN_TOOL_NAMES, EMIT_AUTORAG_RESULTS_TOOL_NAME]);
-              } else {
-                activeSession.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.finalThinkingLevel);
-                activeSession.agent.state.tools = this.tools.filter((tool) => tool.name === EMIT_AUTORAG_RESULTS_TOOL_NAME);
-              }
+              setThinking(this.finalThinkingLevel);
+              if (sessionAgent !== undefined)
+                sessionAgent.setActiveToolsByName([...PI_BUILTIN_TOOL_NAMES]);
+              else
+                activeSession.agent.state.tools = [];
               const configBefore = snapshotConfigFile(this.selfConfig.configPath);
               try {
-                await session.prompt(buildSelfConfigPrompt({
+                await activeSession.prompt(buildSelfConfigPrompt({
                   query: trimmedQuery,
                   configPath: this.selfConfig.configPath,
                   agentDir: this.piAgentDir ?? getAgentDir2(),
                   skill: plan.selfConfigSkill
                 }));
-                if (captured === undefined && !planAbort.signal.aborted && lastModelRequestError(session.piSession?.messages ?? session.agent.state.messages) === undefined) {
-                  await session.prompt(buildFinalEmitReminder());
-                }
+                const report = finalAnswerText(transcript());
+                if (report !== undefined)
+                  captured = this.deriveAnswer(report);
                 const rolledBack = await rollbackIfBroken(this.selfConfig, configBefore);
                 if (rolledBack !== undefined) {
                   this.routingDiagnostics.push({
@@ -18731,11 +19222,10 @@ ${context.text}
                     message: `The edited config did not validate, so the previous config was restored. ${rolledBack}`,
                     source: "self-config"
                   });
-                  const emitted = captured;
-                  if (emitted !== undefined) {
+                  if (captured !== undefined) {
                     captured = {
-                      ...emitted,
-                      answer: `${emitted.answer}
+                      ...captured,
+                      answer: `${captured.answer}
 
 Warning: the edited config did not validate, so the previous config was restored (nothing was changed). Problem: ${rolledBack}`
                     };
@@ -18749,49 +19239,35 @@ Warning: the edited config did not validate, so the previous config was restored
               return;
             }
             if (plan.route === "direct") {
-              activateFastPhase();
-              await session.prompt(this.buildDirectAnswerPrompt(trimmedQuery));
-              const answer = fastCaptured?.answer ?? lastAssistantText(session.piSession?.messages ?? session.agent.state.messages);
+              setThinking(this.fastThinkingLevel);
+              await activeSession.prompt(this.buildDirectAnswerPrompt(trimmedQuery));
+              const answer = finalAnswerText(transcript());
               if (answer !== undefined)
-                captured = { answer, results: [], mapping: [], warnings: [] };
+                captured = this.deriveAnswer(answer);
               return;
             }
             const baseline = await this.prefetchInitialRetrievalContext(trimmedQuery, plan.queries, options, plan.datasources);
-            activateFastPhase();
-            await session.prompt(this.buildFastAnswerPrompt(trimmedQuery, options, baseline));
-            let preliminary = fastCaptured;
-            if (preliminary === undefined) {
-              const text = lastAssistantText(session.piSession?.messages ?? session.agent.state.messages);
-              if (text !== undefined)
-                preliminary = { answer: text, results: [], sources: [], evidenceRefs: [] };
-            }
-            if (preliminary !== undefined)
-              emitPreliminary(preliminary);
-            if (captured !== undefined)
-              return;
+            setThinking(this.fastThinkingLevel);
+            await activeSession.prompt(this.buildFastAnswerPrompt(trimmedQuery, options, baseline));
+            const fastText = finalAnswerText(transcript());
+            const preliminary = fastText === undefined ? undefined : this.deriveAnswer(fastText);
             if (preliminary !== undefined) {
+              emitPreliminary(preliminary);
               const followUp = await this.shouldFollowUp(trimmedQuery, preliminary);
               if (planAbort.signal.aborted)
                 return;
               if (!followUp) {
-                captured = fastAnswerAsFinal(preliminary);
+                captured = preliminary;
                 return;
               }
-            }
-            if (preliminary !== undefined)
               publishPreliminary(preliminary);
-            if (sessionAgent !== undefined) {
-              sessionAgent.setThinkingLevel(clampThinkingLevel(resolved.model, this.finalThinkingLevel));
-              sessionAgent.setActiveToolsByName(sessionAgent.getActiveToolNames().filter((name) => name !== EMIT_FAST_ANSWER_TOOL_NAME));
-            } else {
-              session.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.finalThinkingLevel);
-              session.agent.state.tools = [...this.tools];
             }
+            setThinking(this.finalThinkingLevel);
             const fastAnswerDelivered = preliminary !== undefined && this.preliminaryCallback !== undefined;
-            await session.prompt(this.buildRefinementPrompt(trimmedQuery, options, preliminary, fastAnswerDelivered));
-            if (captured === undefined && !planAbort.signal.aborted && this.searchToolCallCount < this.maxSearchToolCalls && lastModelRequestError(session.piSession?.messages ?? session.agent.state.messages) === undefined) {
-              await session.prompt(buildFinalEmitReminder());
-            }
+            await activeSession.prompt(this.buildRefinementPrompt(trimmedQuery, options, fastText, fastAnswerDelivered));
+            const finalText = finalAnswerText(transcript());
+            if (finalText !== undefined)
+              captured = this.deriveAnswer(finalText);
           })(),
           new Promise((resolve, reject) => {
             timeout = setTimeout(() => {
@@ -18811,7 +19287,7 @@ Warning: the edited config did not validate, so the previous config was restored
           clearTimeout(timeout);
       }
       if (captured === undefined && timedOutAfterFastAnswer && fastCaptured !== undefined) {
-        const response = recordStructuredResultsSession(sessionId, trimmedQuery, fastAnswerAsFinal(fastCaptured), this.sessions, this.memory, [
+        const response = recordStructuredResultsSession(sessionId, trimmedQuery, fastCaptured, this.memory, [
           ...this.collectComponentDiagnostics(),
           {
             code: "search-timeout",
@@ -18845,15 +19321,15 @@ Warning: the edited config did not validate, so the previous config was restored
             sessionId,
             query: trimmedQuery,
             results: [],
-            answer: buildMissingFinalEmitAnswer(trimmedQuery, reason, this.retrievalTrace, modelError),
+            answer: buildMissingFinalAnswer(trimmedQuery, reason, this.retrievalTrace, modelError),
             searched: this.retrievalTrace.reduce((total, entry) => total + entry.resultCount, 0),
             warnings: [],
             diagnostics: [
               ...this.collectComponentDiagnostics(),
               {
-                code: "missing-final-emit",
+                code: "no-final-answer",
                 severity: "warning",
-                message: "The agent ended its run without calling emit_autorag_results; returning a degraded response that carries the run's retrieval trace."
+                message: "The agent ended its run without a final answer message; returning a degraded response that carries the run's retrieval trace."
               },
               ...modelError === undefined ? [] : [
                 {
@@ -18899,7 +19375,7 @@ Warning: the edited config did not validate, so the previous config was restored
           source: "agent"
         });
       }
-      const recorded = recordStructuredResultsSession(sessionId, trimmedQuery, captured, this.sessions, this.memory, componentDiagnostics, { isolateMemory: this.remoteSession || selfConfigRun });
+      const recorded = recordStructuredResultsSession(sessionId, trimmedQuery, captured, this.memory, componentDiagnostics, { isolateMemory: this.remoteSession || selfConfigRun });
       const memoryDiagnostic = selfConfigRun ? undefined : await this.recordJudgedEvidence(sessionId, trimmedQuery, captured);
       const response = memoryDiagnostic === undefined ? recorded : { ...recorded, diagnostics: [...recorded.diagnostics ?? [], memoryDiagnostic] };
       this.runLogger.write({
@@ -18940,36 +19416,25 @@ Warning: the edited config did not validate, so the previous config was restored
         });
       }
       this.activeSession = undefined;
-      this.resultCapture = undefined;
       this.activeRetrievalOptions = undefined;
       this.preliminaryCallback = undefined;
-      if (this.interactiveFastAnswerCallback === emitPreliminary)
-        this.interactiveFastAnswerCallback = undefined;
       this.activeRun = false;
       this.memoryContextCache = undefined;
     }
   }
   async* searchDocumentsStream(query, options = {}) {
     const queue = [];
-    let progressBuffer = "";
     let wake;
     let settled = false;
     const unsubscribe = this.subscribe((event) => {
-      if (event.type !== "message_update" || event.assistantMessageEvent.type !== "text_delta")
+      if (event.type !== "message_end" || event.message.role !== "assistant")
         return;
-      const text = event.assistantMessageEvent.delta;
-      if (text.trim().length === 0)
+      if (event.message.stopReason !== "toolUse")
         return;
-      progressBuffer += text;
-      if (!/[.!?。！？]\s*$/u.test(progressBuffer))
+      const text = event.message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+      if (text === "")
         return;
-      queue.push({
-        type: "progress",
-        sessionId: this.lastSessionId ?? "",
-        query: query.trim(),
-        text: progressBuffer
-      });
-      progressBuffer = "";
+      queue.push({ type: "progress", sessionId: this.lastSessionId ?? "", query: query.trim(), text });
       wake?.();
       wake = undefined;
     });
@@ -18985,15 +19450,6 @@ Warning: the edited config did not validate, so the previous config was restored
       wake = undefined;
     };
     const run = this.searchDocuments(query, options).then((response) => {
-      if (progressBuffer.trim() !== "") {
-        queue.push({
-          type: "progress",
-          sessionId: this.lastSessionId ?? "",
-          query: query.trim(),
-          text: progressBuffer
-        });
-        progressBuffer = "";
-      }
       queue.push({ type: "complete", response });
     }).catch((error) => {
       settled = true;
@@ -19384,7 +19840,7 @@ ${result.content.replace(/\s+/gu, " ")}`).join(`
     }
   }
   buildFastAnswerPrompt(query, options, baseline) {
-    const limit = typeof options.topK === "number" ? ` Return at most ${options.topK} knowledge units.` : "";
+    const limit = typeof options.topK === "number" ? ` Cite at most ${options.topK} sources.` : "";
     const scope = options.scope ? ` Restrict search to virtual path scope ${options.scope}.` : "";
     return `Answer this original query immediately: ${query}${limit}${scope}
 
@@ -19396,21 +19852,18 @@ ${baseline}
 ` + `Formatting and content rules for the answer:
 ` + `- Provide the core answer to the user's question in at most 5 bullet points. If additional explanation is necessary, append it after the bullet points.
 ` + `- Answer the question directly. Do not include specific file paths, datasource descriptions, or retrieval mechanics in the answer text.
-` + `- Cite evidence with bracketed numbers only (e.g. [1], [2]); do not quote raw chunks or mention source paths directly in the answer.
 ` + `- ${ANSWER_CITATION_RULE}
 ` + `- ${ANSWER_IMAGE_EMBED_RULE}
 ` + `- Do not report per-source negative findings (e.g. "no information found in Slack" or "checked Drive but found nothing").
 ` + `- When evidence conflicts, treat the freshest (most recent) information as the correct source of truth.
 ` + `- If information is incomplete or uncertain, acknowledge it briefly without lengthy explanations, stating that it is difficult to answer fully with the given information and searching continues. If there are partial clues or leads (even if not the exact answer), mention those clues concisely.
 
-` + `Call emit_fast_answer exactly once with the answer, its numbered knowledge units, and the evidence ids (e.g. e3) from the baseline evidence that back each unit in refs, then stop.`;
+` + `Write the answer as your reply, then stop.`;
   }
   buildDirectAnswerPrompt(query) {
     return `Answer this query directly from your own general knowledge: ${query}
 
-` + `It needs no search: it is general knowledge, simple reasoning, or conversation. Do NOT call any search, retrieval, web, or file-reading tools. ` + `Reply naturally and concisely; for small talk, just respond conversationally. Do not cite sources or mention retrieval.
-
-` + `Call emit_fast_answer exactly once with the answer and an empty results list, then stop.`;
+` + `It needs no search: it is general knowledge, simple reasoning, or conversation. Do NOT call any search, retrieval, web, or file-reading tools. ` + `Reply naturally and concisely; for small talk, just respond conversationally. Do not cite sources or mention retrieval.`;
   }
   discoveryHint(sentence) {
     const names = this.tools.map((tool) => tool.name).filter((name) => name === JIKJI_FIND_TOOL_NAME || name === EVERYTHING_SEARCH_TOOL_NAME);
@@ -19424,22 +19877,20 @@ ${baseline}
     return `When local evidence is missing, thin, or possibly outdated — or the question concerns current events, recent releases, prices, or other public facts — use ${WEB_SEARCH_TOOL_NAME}${fetch2} to confirm or correct claims and fill gaps; use URLs as result sources for web-derived evidence. `;
   }
   buildRefinementPrompt(query, options, fastAnswer, fastAnswerDelivered) {
-    const limit = typeof options.topK === "number" ? ` Return at most ${options.topK} curated results.` : "";
+    const limit = typeof options.topK === "number" ? ` Cite at most ${options.topK} sources.` : "";
     const scope = options.scope ? ` Restrict search to virtual path scope ${options.scope}.` : "";
     const firstAnswer = formatFirstAnswerContext(fastAnswer, fastAnswerDelivered);
-    const answerRules = fastAnswerDelivered ? `Formatting and content rules for the final \`answer\` (DELTA ONLY):
-` + `- The user already has the first answer above. \`answer\` MUST contain only the delta against it: (a) corrections to anything in the first answer that is wrong, unsupported, or outdated, and (b) newly verified findings that were not present in the first answer.
+    const answerRules = fastAnswerDelivered ? `Formatting and content rules for your final answer (DELTA ONLY):
+` + `- The user already has the first answer above. Your final answer MUST contain only the delta against it: (a) corrections to anything in the first answer that is wrong, unsupported, or outdated, and (b) newly verified findings that were not present in the first answer.
 ` + `- NEVER restate or re-list first-answer facts that remain correct, and never repeat its bullet list.
 ` + `- Mark each item clearly as a correction or as a new finding.
 ` + `- If verification changed nothing and found nothing new, say so in one short line (the first answer is confirmed as-is) instead of restating it.
-` + `- Cite evidence with bracketed numbers only (e.g. [1], [2]); do not quote raw chunks or mention source paths directly in the answer.
-` + `- ${ANSWER_CITATION_RULE} A correction or new finding that relies on a first-answer unit must re-emit that evidence as a result of this call and cite its new number.
+` + `- ${ANSWER_CITATION_RULE} A correction or new finding that relies on evidence the first answer cited must cite that evidence's id again.
 ` + `- ${ANSWER_IMAGE_EMBED_RULE} ${ANSWER_IMAGE_DELTA_RULE}
 ` + `- Do not report per-source negative findings (e.g. "no information found in Slack").
 ` + `- When evidence conflicts, treat the freshest (most recent) information as the correct source of truth.` : `Formatting and content rules for the final answer (COMPLETE — no first answer reached the caller):
 ` + `- Provide the core answer to the user's question in at most 5 bullet points. If additional explanation is necessary, append it after the bullet points.
 ` + `- Answer the question directly. Do not include specific file paths, datasource descriptions, or retrieval mechanics in the answer text.
-` + `- Cite evidence with bracketed numbers only (e.g. [1], [2]); do not quote raw chunks or mention source paths directly in the answer.
 ` + `- ${ANSWER_CITATION_RULE}
 ` + `- ${ANSWER_IMAGE_EMBED_RULE}
 ` + `- Do not report per-source negative findings (e.g. "no information found in Slack").
@@ -19448,35 +19899,34 @@ ${baseline}
 
 ` + `${firstAnswer}
 
-` + `Now verify it rigorously. ${this.discoveryHint((tools) => `Actively use ${tools} when discovering or exploring local files and folders. `)}Check important claims against source files with bash when needed, correct anything wrong or unsupported, fill gaps with retrieval tools, and resolve conflicts and freshness. ${this.webFallbackHint()}` + `Cite the evidence ids (e.g. e3) shown next to retrieved results in each result's refs; for a local file you opened yourself with bash, give its absolute path.
+` + `Now verify it rigorously. ${this.discoveryHint((tools) => `Actively use ${tools} when discovering or exploring local files and folders. `)}Check important claims against source files with bash when needed, correct anything wrong or unsupported, fill gaps with retrieval tools, and resolve conflicts and freshness. ${this.webFallbackHint()}
 
 ` + `${answerRules}
 
-` + `Do not use broad grep/find or recursive filesystem scans: only inspect a path or narrow neighborhood surfaced by retrieval, and only when evidence clearly points there. ` + `Avoid spinning repeated near-identical queries against the same datasource; once additional attempts stop surfacing new evidence, conclude from the evidence available. ` + `If more search is needed, first write a brief 1–2 line progress update stating the best current hypothesis and what you are checking next, then call retrieval tools. ` + `When finished, call ${EMIT_AUTORAG_RESULTS_TOOL_NAME} exactly once as your final action with the curated ` + `results, each citing its supporting evidence ids in refs.`;
+` + `Do not use broad grep/find or recursive filesystem scans: only inspect a path or narrow neighborhood surfaced by retrieval, and only when evidence clearly points there. ` + `Avoid spinning repeated near-identical queries against the same datasource; once additional attempts stop surfacing new evidence, conclude from the evidence available. ` + `If more search is needed, first write a brief 1–2 line progress update stating the best current hypothesis and what you are checking next, then call retrieval tools. ` + `When finished, reply with the final answer and no tool call: that last reply is what the user receives, so keep progress notes out of it.`;
   }
   buildSearchPrompt(query, options, initialRetrievalContext) {
-    const limit = typeof options.topK === "number" ? ` Return at most ${options.topK} curated results.` : "";
+    const limit = typeof options.topK === "number" ? ` Cite at most ${options.topK} sources.` : "";
     const scope = options.scope ? ` Restrict search to virtual path scope ${options.scope}.` : "";
     return `Find and curate information for this original query: ${query}${limit}${scope}
 
-` + `Start by deciding whether this is answerable from general knowledge or memory. If it is a generic, stable question, answer it immediately without retrieval and emit the structured result. ` + `Otherwise, baseline MinSync and Jikji retrieval is already running in parallel; do not emit final results until its next message arrives.
+` + `Start by deciding whether this is answerable from general knowledge or memory. If it is a generic, stable question, answer it immediately without retrieval. ` + `Otherwise, baseline MinSync and Jikji retrieval is already running in parallel; do not give the final answer until its next message arrives.
 
 ` + `Baseline retrieval context:
 ${initialRetrievalContext ?? "Pending; continue only with a brief progress statement."}
 
-` + `Treat candidates as unverified evidence, verify important claims against source files when needed, and use additional tools when needed. ` + `Judge relevance, conflicts, freshness, and sufficiency in this agent loop. Cite the evidence ids (e.g. e3) shown next to retrieved results in each result's refs.
+` + `Treat candidates as unverified evidence, verify important claims against source files when needed, and use additional tools when needed. ` + `Judge relevance, conflicts, freshness, and sufficiency in this agent loop.
 
 ` + `Formatting and content rules for the answer:
 ` + `- Provide the core answer to the user's question in at most 5 bullet points. If additional explanation is necessary, append it after the bullet points.
 ` + `- Answer the question directly. Do not include specific file paths, datasource descriptions, or retrieval mechanics in the answer text.
-` + `- Cite evidence with bracketed numbers only (e.g. [1], [2]); do not quote raw chunks or mention source paths directly in the answer.
 ` + `- ${ANSWER_CITATION_RULE}
 ` + `- ${ANSWER_IMAGE_EMBED_RULE}
 ` + `- Do not report per-source negative findings (e.g. "no information found in Slack").
 ` + `- When evidence conflicts, treat the freshest (most recent) information as the correct source of truth.
 ` + `- If information is incomplete or uncertain, acknowledge it briefly without lengthy explanations. If there are partial clues or leads, mention them concisely.
 
-` + `${this.discoveryHint((tools) => `When exploring local files and folders, actively use ${tools} rather than exploratory bash commands. `)}If more search is needed, first write a brief 1–2 line progress update stating the best current hypothesis and what you are checking next, then call retrieval tools. ` + `Never repeat a generic status message. Do not use broad grep/find or recursive filesystem scans: only inspect a path or narrow neighborhood surfaced by retrieval, and only when evidence clearly points there. ` + `Avoid spinning repeated near-identical queries against the same datasource; once additional attempts stop surfacing new evidence, conclude from the evidence available. ` + `When finished, call ${EMIT_AUTORAG_RESULTS_TOOL_NAME} exactly once as your final action with the curated ` + `results, each citing its supporting evidence ids in refs.`;
+` + `${this.discoveryHint((tools) => `When exploring local files and folders, actively use ${tools} rather than exploratory bash commands. `)}If more search is needed, first write a brief 1–2 line progress update stating the best current hypothesis and what you are checking next, then call retrieval tools. ` + `Never repeat a generic status message. Do not use broad grep/find or recursive filesystem scans: only inspect a path or narrow neighborhood surfaced by retrieval, and only when evidence clearly points there. ` + `Avoid spinning repeated near-identical queries against the same datasource; once additional attempts stop surfacing new evidence, conclude from the evidence available. ` + `When finished, reply with the final answer and no tool call: that last reply is what the user receives, so keep progress notes out of it.`;
   }
   async refresh(force = false, opts) {
     const methods = opts?.methods;
@@ -20108,57 +20558,21 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
 function formatRerankedBaseline(results, evidenceIds) {
   const lines = results.map((result, index) => `[${evidenceIds[index]}] ${result.source}
 ${result.content.replace(/\s+/gu, " ")}`);
-  return `Reranked initial candidates (ordered by relevance to the query; cite evidence by its [eN] id in refs):
+  return `Reranked initial candidates (ordered by relevance to the query; cite evidence by its [eN] id):
 ${lines.join(`
 `)}`;
 }
-function fastAnswerAsFinal(fastAnswer) {
-  const refsByNumber = new Map(fastAnswer.evidenceRefs.map((entry) => [entry.number, entry.refs]));
-  return {
-    answer: fastAnswer.answer,
-    results: fastAnswer.results.map((result) => ({
-      number: result.number,
-      title: result.title,
-      summary: result.summary,
-      evidence: result.evidence,
-      confidence: result.confidence ?? 0.5
-    })),
-    mapping: fastAnswer.results.map((result) => {
-      const refs = refsByNumber.get(result.number) ?? [];
-      const primary = refs[0];
-      return {
-        number: result.number,
-        source: primary?.source ?? "",
-        method: primary?.method ?? EMIT_FAST_ANSWER_TOOL_NAME,
-        content: primary?.content ?? (result.evidence.map((evidence) => evidence.excerpt).join(`
-`) || result.summary),
-        evidenceRefs: refs
-      };
-    }),
-    warnings: []
-  };
-}
 function formatFirstAnswerContext(fastAnswer, delivered) {
   if (fastAnswer === undefined) {
     return "(the fast phase produced no answer — write the complete answer)";
   }
-  const header = delivered ? "The user has ALREADY received this immediate first answer:" : "An internal first-pass draft was produced but was NOT shown to the caller; write the complete answer:";
-  const units = fastAnswer.results.length === 0 ? "" : `
-
-Numbered units of that first answer (its own numbering — NOT citation numbers for your final answer; cite only the results you emit):
-${fastAnswer.results.map((result) => `[${result.number}] ${result.title} — ${result.summary}`).join(`
-`)}`;
-  const sources = fastAnswer.sources.length === 0 ? "" : `
-
-Sources of that first answer:
-${fastAnswer.sources.map((entry) => `[${entry.number}] -> ${entry.source}`).join(`
-`)}`;
+  const header = delivered ? "The user has ALREADY received this immediate first answer (its citations were renumbered for the user; the [eN] ids below are still valid for you):" : "An internal first-pass draft was produced but was NOT shown to the caller; write the complete answer:";
   return `${header}
-${fastAnswer.answer}${units}${sources}`;
+${fastAnswer}`;
 }
-function buildMissingFinalEmitAnswer(query, reason, trace, modelError) {
+function buildMissingFinalAnswer(query, reason, trace, modelError) {
   const lines = [
-    `The search run for "${query}" ended without finalized results: the agent ended its run without calling emit_autorag_results, so no curated answer is available within the configured search range.`,
+    `The search run for "${query}" ended without a final answer: the agent stopped before writing one, so no curated answer is available within the configured search range.`,
     ...modelError === undefined ? [] : [`The model request failed: ${modelError}`],
     ...reason === undefined ? modelError === undefined ? ["The agent did not record why it stopped."] : [] : [`The agent's last note before stopping: "${reason.length > 500 ? `${reason.slice(0, 500)}…` : reason}"`],
     modelError === undefined ? "Next steps: broaden the configured searchPaths, connect additional datasources via the datasources configuration, or retry with a narrower or different query." : "Next steps: fix the model provider error above (rate limit, quota, credentials, or model id) and retry the same query.",
@@ -20179,8 +20593,17 @@ function lastModelRequestError(messages) {
   }
   return;
 }
-function buildFinalEmitReminder() {
-  return `You ended without calling ${EMIT_AUTORAG_RESULTS_TOOL_NAME}, so the user has not received your verified answer. ` + `Do not search again. Call ${EMIT_AUTORAG_RESULTS_TOOL_NAME} now, exactly once, with the answer you just wrote, ` + `its numbered results, each with the evidence ids (refs) of the sources you used (a local file you opened yourself: its absolute path). ` + `If verification found nothing usable, call it with an answer that says so and an empty results list.`;
+function finalAnswerText(messages) {
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    if (message.role !== "assistant")
+      continue;
+    if (message.stopReason !== "stop")
+      return;
+    const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+    return text === "" ? undefined : text;
+  }
+  return;
 }
 function lastAssistantText(messages) {
   for (let index = messages.length - 1;index >= 0; index--) {
@@ -20342,13 +20765,12 @@ var init_agent = __esm(() => {
   init_rerank();
   init_scope();
   init_model_auth();
+  init_answer_citations();
   init_datasource_skill();
   init_dupey_tool();
-  init_emit_results_tool();
   init_everything_search_tool();
   init_evidence_judgment();
   init_evidence_ledger();
-  init_fast_answer_tool();
   init_fsearch_search_tool();
   init_jev_extension();
   init_jikji_find_tool();
@@ -20790,7 +21212,7 @@ function datasourceCliError(datasourceId, command, failure) {
   return new DatasourceCliError(datasourceId, command, failure);
 }
 var DatasourceCliError;
-var init_errors3 = __esm(() => {
+var init_errors4 = __esm(() => {
   DatasourceCliError = class DatasourceCliError extends Error {
     datasourceId;
     command;
@@ -20882,7 +21304,7 @@ function toResult(hit, source, mode, instanceId) {
   };
 }
 var init_methods = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
 });
 
@@ -21476,7 +21898,7 @@ var init_rclone_connector = __esm(() => {
 });
 
 // src/datasource/connector.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function connectorFailureToDiagnosticCode(reason) {
   switch (reason) {
     case "auth":
@@ -21510,7 +21932,7 @@ function sanitizeIdSegment(value) {
   const cleaned = normalized.slice(start, end);
   if (cleaned === value && cleaned.length > 0 && cleaned.length <= 80)
     return cleaned;
-  const hash = createHash11("sha256").update(value).digest("hex").slice(0, 8);
+  const hash = createHash12("sha256").update(value).digest("hex").slice(0, 8);
   const stem = cleaned.slice(0, 60);
   return stem.length > 0 ? `${stem}-${hash}` : hash;
 }
@@ -22709,7 +23131,7 @@ function toRetrievalResult(hit, source, methodName, instanceId, mode, diagnostic
 }
 var DISCORD_DATASOURCE_ID = "discord", DEFAULT_DISCORD_TAGS, DEFAULT_TOP_K2 = 20;
 var init_methods2 = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
   init_paths3();
   DEFAULT_DISCORD_TAGS = ["discord", "chat", "pii"];
@@ -23007,7 +23429,7 @@ class GitHubConnector {
     if (repos.length === 0)
       return { ok: false, reason: "not-configured", message: "no repositories configured" };
     const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV);
-    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL3;
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL4;
     const request = {
       headers: {
         Accept: "application/vnd.github+json",
@@ -23080,7 +23502,7 @@ ${body}` : title,
     return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
   }
 }
-var DEFAULT_BASE_URL3 = "https://api.github.com", DEFAULT_TOKEN_ENV = "GITHUB_TOKEN", DEFAULT_MAX_PAGES = 10, DEFAULT_MAX_DOCUMENTS2 = 500;
+var DEFAULT_BASE_URL4 = "https://api.github.com", DEFAULT_TOKEN_ENV = "GITHUB_TOKEN", DEFAULT_MAX_PAGES = 10, DEFAULT_MAX_DOCUMENTS2 = 500;
 var init_connector2 = () => {};
 
 // src/datasource/skills/github/skill.ts
@@ -23147,7 +23569,7 @@ class GitHubGistConnector {
         message: "no GitHub token: set GITHUB_TOKEN (or connector.tokenEnv) or authenticate the gh CLI"
       };
     }
-    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL4;
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL5;
     const request = {
       headers: {
         Accept: "application/vnd.github+json",
@@ -23296,15 +23718,15 @@ ${content}`);
     }
   };
 }
-var DEFAULT_BASE_URL4 = "https://api.github.com", DEFAULT_TOKEN_ENV2 = "GITHUB_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_GISTS = 500, GH_TOKEN_TIMEOUT_MS = 5000, STATE_VERSION = 1;
+var DEFAULT_BASE_URL5 = "https://api.github.com", DEFAULT_TOKEN_ENV2 = "GITHUB_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_GISTS = 500, GH_TOKEN_TIMEOUT_MS = 5000, STATE_VERSION = 1;
 var init_connector3 = () => {};
 
 // src/datasource/skills/github-gist/semantic.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { existsSync as existsSync26, mkdirSync as mkdirSync22, readFileSync as readFileSync23, writeFileSync as writeFileSync21 } from "node:fs";
 import { dirname as dirname21 } from "node:path";
 function contentHash(chunk) {
-  return createHash12("sha256").update(`${chunk.title ?? ""}
+  return createHash13("sha256").update(`${chunk.title ?? ""}
 ${chunk.content}`).digest("hex");
 }
 function sameIdentity(a, b) {
@@ -24234,7 +24656,7 @@ function isRemoteEmbedder(value) {
 }
 var CHAT_TAG = "lark:chat", DOCS_TAG = "lark:docs", DEFAULT_TAGS2, REMOTE_NOTE = "remote-search datasource: no local mirror";
 var init_skill6 = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
   init_client7();
   DEFAULT_TAGS2 = [CHAT_TAG, DOCS_TAG];
@@ -24762,7 +25184,7 @@ function toRetrievalResult2(hit, source, methodName, instanceId, mode) {
 }
 var KAKAO_DATASOURCE_ID = "kakao", DEFAULT_KAKAO_TAGS, DEFAULT_TOP_K4 = 20;
 var init_methods3 = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_paths4();
   DEFAULT_KAKAO_TAGS = ["kakaotalk", "personal", "pii"];
 });
@@ -25116,7 +25538,7 @@ function ensurePrivateMailcrawlDataDir(path) {
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
-var init_config = () => {};
+var init_config2 = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
 import { spawn as spawn15 } from "node:child_process";
@@ -25442,7 +25864,7 @@ function truncateUtf8(value, maxBytes) {
 var DEFAULT_BINARY4 = "mailcrawl", DEFAULT_SEARCH_TIMEOUT_MS3 = 60000, DEFAULT_INDEX_TIMEOUT_MS3 = 1800000, DEFAULT_MAX_BUFFER_BYTES4 = 1048576, LOOPBACK_HOSTS2, SAFE_ENV_KEYS2, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
 var init_client9 = __esm(() => {
   init_portable_spawn();
-  init_config();
+  init_config2();
   LOOPBACK_HOSTS2 = new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
   SAFE_ENV_KEYS2 = new Set(["HOME", "LANG", "LC_ALL", "PATH", "TMPDIR", "TMP", "TEMP", "NO_COLOR"]);
   SAFE_MAILCRAWL_ENV_KEYS = new Set([
@@ -25541,7 +25963,7 @@ class MailcrawlMethod {
 }
 var modes, MAILCRAWL_MODES;
 var init_methods4 = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
   modes = ["bm25", "semantic", "hybrid"];
   MAILCRAWL_MODES = modes;
@@ -25689,7 +26111,7 @@ var TAGS;
 var init_skill9 = __esm(() => {
   init_scope2();
   init_client9();
-  init_config();
+  init_config2();
   init_methods4();
   TAGS = ["mailcrawl", "email", "pii"];
 });
@@ -25909,7 +26331,7 @@ function failureCode2(reason) {
 }
 var DEFAULT_INSTANCE_ID5 = "default", DEFAULT_POLLING_INTERVAL_MS4;
 var init_crawler_skill = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
   DEFAULT_POLLING_INTERVAL_MS4 = 15 * 60 * 1000;
 });
@@ -26095,7 +26517,7 @@ var DEFAULT_QMD_BINARY = "qmd", DEFAULT_QMD_TIMEOUT_MS = 60000, DEFAULT_QMD_MAX_
 // src/datasource/skills/obsidian/client.ts
 import { spawn as spawn16 } from "node:child_process";
 import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync22 } from "node:fs";
-import { isAbsolute as isAbsolute7, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute8, resolve as resolve14 } from "node:path";
 
 class QmdClient {
   options;
@@ -26191,7 +26613,7 @@ function resolveVaultPath(vaultPath) {
   if (vaultPath === undefined || vaultPath.trim().length === 0)
     return;
   const trimmed = vaultPath.trim();
-  return isAbsolute7(trimmed) ? trimmed : resolve14(trimmed);
+  return isAbsolute8(trimmed) ? trimmed : resolve14(trimmed);
 }
 function controlledEnv5(options) {
   const instanceId = options.instanceId ?? "default";
@@ -26547,7 +26969,7 @@ function toRetrievalResult3(hit, source, methodName, instanceId, mode) {
 }
 var OBSIDIAN_DATASOURCE_ID = "obsidian", DEFAULT_OBSIDIAN_TAGS, DEFAULT_TOP_K5 = 20;
 var init_methods5 = __esm(() => {
-  init_errors3();
+  init_errors4();
   init_scope2();
   DEFAULT_OBSIDIAN_TAGS = ["obsidian", "notes"];
 });
@@ -27085,7 +27507,7 @@ var init_slack = __esm(() => {
 
 // src/datasource/skills/spotlight/connector.ts
 import { spawn as spawn17 } from "node:child_process";
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat7 } from "node:fs/promises";
 import { basename as basename13, extname as extname8 } from "node:path";
 
@@ -27170,7 +27592,7 @@ class SpotlightConnector {
         if (content.length === 0)
           continue;
         documents.push({
-          docId: createHash13("sha256").update(path).digest("hex").slice(0, 16),
+          docId: createHash14("sha256").update(path).digest("hex").slice(0, 16),
           hierarchy: ["files"],
           title: basename13(path),
           content,
@@ -27765,7 +28187,7 @@ var init_factory = __esm(() => {
 // src/cli/config.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync28, mkdirSync as mkdirSync25, readFileSync as readFileSync24, renameSync as renameSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync23 } from "node:fs";
-import { basename as basename14, dirname as dirname23, isAbsolute as isAbsolute8, join as join36, resolve as resolve15 } from "node:path";
+import { basename as basename14, dirname as dirname23, isAbsolute as isAbsolute9, join as join36, resolve as resolve15 } from "node:path";
 import { findEnvKeys, getEnvApiKey } from "@earendil-works/pi-ai/compat";
 import { getAgentDir as getAgentDir3, ModelRuntime as ModelRuntime2, SettingsManager as SettingsManager2 } from "@earendil-works/pi-coding-agent";
 function resolveConfigPath(input) {
@@ -27893,7 +28315,7 @@ function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
 }
 function resolvePersistedPath(path, origin) {
-  return isAbsolute8(path) ? path : resolve15(origin, path);
+  return isAbsolute9(path) ? path : resolve15(origin, path);
 }
 function normalizeLegacyConfigPaths(partial, origin) {
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", origin);
@@ -28733,11 +29155,15 @@ function getModelRuntime(agentDir) {
   const cached = modelRuntimeCache.get(agentDir);
   if (cached !== undefined)
     return cached;
-  const created = ModelRuntime2.create({
-    authPath: join36(agentDir, "auth.json"),
-    modelsPath: join36(agentDir, "models.json"),
-    allowModelNetwork: false
-  });
+  const created = (async () => {
+    const runtime = await ModelRuntime2.create({
+      authPath: join36(agentDir, "auth.json"),
+      modelsPath: join36(agentDir, "models.json"),
+      allowModelNetwork: false
+    });
+    await registerAutoRAGProvider(runtime);
+    return runtime;
+  })();
   modelRuntimeCache.set(agentDir, created);
   created.catch(() => {
     modelRuntimeCache.delete(agentDir);
@@ -29066,8 +29492,9 @@ function writeDefaultConfig(path, partial, opts = {}) {
   }
 }
 var DEFAULT_CONFIG_FILENAME = "config.json", LEGACY_CONFIG_FILENAME = "autorag.config.json", CONFIG_LOCK_RETRY_MS = 10, CONFIG_LOCK_TIMEOUT_MS = 1e4, CONFIG_LOCK_STALE_MS = 30000, ConfigError, MINSYNC_REQUIRED_MESSAGE = "MinSync is required and cannot be disabled; remove `minSync: false` / `minSync.enabled: false` from the config.", AGENT_MODEL_APIS, AGENT_MODEL_INPUTS, API_KEY_ENV_PATTERN2, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, MINSYNC_ALLOWLIST, MINSYNC_LEGACY_IGNORED, P2P_ALLOWLIST, P2P_QUOTA_ALLOWLIST, LIMITS_ALLOWLIST, LIMITS_PREFETCH_ALLOWLIST, JEV_CONFIG_FIELDS, JEV_BACKEND_NAMES, DEFAULT_JEV_BACKEND = "openrouter", DEFAULT_QUERY_DECOMPOSITION_MODEL, RERANK_ALLOWLIST, UNKNOWN_MODEL_HINT = "Add baseUrl (and optional api/apiKeyEnv) for an OpenAI-compatible endpoint outside the pi-ai catalog, or use a pi-ai catalog model id.", modelRuntimeCache;
-var init_config2 = __esm(() => {
+var init_config3 = __esm(() => {
   init_local_model();
+  init_provider();
   init_home();
   init_factory();
   init_file_lock();
@@ -29162,7 +29589,6 @@ class AutoRAGLite {
   agent;
   retrievalEngine;
   memory;
-  sessions = new Map;
   constructor(config) {
     this.config = config;
     const agentOptions = buildAgentOptions(config);
@@ -29217,14 +29643,11 @@ class AutoRAGLite {
     return this.retrievalEngine.retrieveByMethod(query, options);
   }
   recordStructuredResultsSession(sessionId, query, details) {
-    return recordStructuredResultsSession(sessionId, query, details, this.sessions, this.memory);
+    return recordStructuredResultsSession(sessionId, query, details, this.memory);
   }
   recordReport(query, details) {
     return this.recordStructuredResultsSession(randomUUID10(), query, details);
   }
-  getResultRegistry(sessionId) {
-    return this.sessions.get(sessionId)?.registry ?? new Map;
-  }
   getMemorySchema() {
     return structuredClone(this.memory.getSchema());
   }
@@ -29242,9 +29665,9 @@ function createAutoRAGLite(options = {}) {
 var init_core = __esm(() => {
   init_agent();
   init_search_documents();
-  init_config2();
+  init_config3();
   init_memory();
-  init_config2();
+  init_config3();
 });
 
 // src/cli/output.ts
@@ -29418,7 +29841,8 @@ function searchEnvelope(resp, debug) {
     if (r.source !== undefined)
       base.source = r.source;
     if (debug) {
-      base.confidence = r.confidence;
+      if (r.confidence !== undefined)
+        base.confidence = r.confidence;
       base.evidence = r.evidence.map((e) => {
         const ev = { excerpt: e.excerpt };
         if (e.lineNumber !== undefined)
@@ -29455,7 +29879,8 @@ function renderSearchHuman(resp, debug) {
     if (r.summary)
       lines.push(`   ${r.summary}`);
     if (debug) {
-      lines.push(`   confidence: ${r.confidence}`);
+      if (r.confidence !== undefined)
+        lines.push(`   confidence: ${r.confidence}`);
       for (const ev of r.evidence) {
         const ln = ev.lineNumber !== undefined ? ` (line ${ev.lineNumber})` : "";
         lines.push(`   evidence${ln}: ${ev.excerpt}`);
@@ -29687,7 +30112,61 @@ async function runEvidence(ctx) {
 }
 var init_evidence = __esm(() => {
   init_memory();
-  init_config2();
+  init_config3();
+});
+
+// src/agent/results.ts
+import { Type as Type17 } from "typebox";
+var evidenceRefSchema, answerSchema, warningsSchema, curatedResultFields, reportSchema;
+var init_results = __esm(() => {
+  evidenceRefSchema = Type17.Object({
+    method: Type17.String({ description: "Retrieval method namespace for this evidence chunk" }),
+    source: Type17.String({ description: "Internal opaque source identifier for this evidence chunk" }),
+    excerpt: Type17.Optional(Type17.String({ description: "Evidence excerpt used for stable ID normalization" })),
+    content: Type17.Optional(Type17.String({ description: "Evidence content used for stable ID normalization" })),
+    retrievalResultId: Type17.Optional(Type17.String({ description: "Backend retrieval ID when path-opaque and stable" })),
+    chunkIndex: Type17.Optional(Type17.Integer({ description: "Chunk index, if available" })),
+    lineNumber: Type17.Optional(Type17.Integer({ description: "Line number, if available" })),
+    stableEvidenceId: Type17.Optional(Type17.String({ description: "Stable evidence ID, if already normalized" })),
+    retrieverMix: Type17.Optional(Type17.Array(Type17.String({ maxLength: 64 }), {
+      description: "Retrievers that contributed to this result",
+      maxItems: 8
+    })),
+    parserType: Type17.Optional(Type17.String({ description: "Parser that produced this evidence", maxLength: 120 })),
+    documentType: Type17.Optional(Type17.String({ description: "Document type, if known", maxLength: 120 })),
+    documentArea: Type17.Optional(Type17.String({ description: "Document collection area, if known", maxLength: 120 })),
+    evidenceType: Type17.Optional(Type17.String({ description: "Evidence type, if known", maxLength: 120 })),
+    evidenceLocation: Type17.Optional(Type17.String({ description: "Human-readable evidence location", maxLength: 120 })),
+    confidence: Type17.Optional(Type17.Number({ description: "Evidence confidence, 0..1", minimum: 0, maximum: 1 }))
+  });
+  answerSchema = Type17.String({
+    description: `Answer for the caller. At most 5 bullet points (plus optional explanation); reference results by bracketed number (e.g. [1], [2]) without file paths or raw chunk text, except the image-embed exception below. ${ANSWER_CITATION_RULE} ${ANSWER_IMAGE_EMBED_RULE}`
+  });
+  warningsSchema = Type17.Optional(Type17.Array(Type17.String(), { description: "Optional warnings about this result set" }));
+  curatedResultFields = {
+    number: Type17.Integer({ description: "1-based result number" }),
+    title: Type17.String({ description: "Short name of the curated knowledge unit" }),
+    summary: Type17.String({ description: "Key insight: purpose, details, and line range" }),
+    evidence: Type17.Array(Type17.Object({
+      excerpt: Type17.String({ description: "Supporting excerpt" }),
+      lineNumber: Type17.Optional(Type17.Integer({ description: "Line number of the excerpt, if known" }))
+    })),
+    confidence: Type17.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 })
+  };
+  reportSchema = Type17.Object({
+    answer: answerSchema,
+    results: Type17.Array(Type17.Object(curatedResultFields), { description: "Numbered curated knowledge units." }),
+    mapping: Type17.Array(Type17.Object({
+      number: Type17.Integer({ description: "Matches the result number this entry maps" }),
+      source: Type17.String({ description: "Source identifier — a real file path or a datasource id" }),
+      method: Type17.String({ description: "Retrieval method or tool that produced the source" }),
+      content: Type17.String({ description: "Raw content snippet of the evidence behind this result" }),
+      evidenceRefs: Type17.Optional(Type17.Array(evidenceRefSchema, {
+        description: "Hidden evidence chunk references supporting this curated result"
+      }))
+    }), { description: "Internal number -> source/method mapping. One entry per result number." }),
+    warnings: warningsSchema
+  });
 });
 
 // src/cli/commands/report.ts
@@ -29785,9 +30264,9 @@ async function runReport(ctx) {
 }
 var MAX_REPORTED_SCHEMA_ERRORS = 8;
 var init_report = __esm(() => {
-  init_emit_results_tool();
+  init_results();
   init_core();
-  init_config2();
+  init_config3();
 });
 
 // src/mcp/index.ts
@@ -29809,7 +30288,7 @@ import { z as z2 } from "zod";
 // src/filesystem/name-search.ts
 import { realpathSync as realpathSync6 } from "node:fs";
 import { lstat, readdir as readdir4 } from "node:fs/promises";
-import { basename as basename15, dirname as dirname24, isAbsolute as isAbsolute9, join as join37, relative as relative6, resolve as resolve16, sep as sep7 } from "node:path";
+import { basename as basename15, dirname as dirname24, isAbsolute as isAbsolute10, join as join37, relative as relative6, resolve as resolve16, sep as sep7 } from "node:path";
 var SKIP_DIR_NAMES2 = {
   ".git": true,
   ".autorag": true,
@@ -29956,7 +30435,7 @@ async function pinConfiguredRoots(roots, diagnostics) {
   return outermost;
 }
 async function resolveRequestRoots(requestRoot, pinnedRoots) {
-  const candidates = isAbsolute9(requestRoot) ? [requestRoot] : pinnedRoots.map((root) => resolve16(root, requestRoot));
+  const candidates = isAbsolute10(requestRoot) ? [requestRoot] : pinnedRoots.map((root) => resolve16(root, requestRoot));
   const allowed = [];
   for (const candidate of candidates) {
     let real;