@autorag/librarian 2.6.3 → 2.7.0

package/dist/core.js

@@ -7764,8 +7764,9 @@ function createReranker(config) {
   if (config === false || config === undefined)
     return;
   const provider = config.provider ?? DEFAULT_RERANK_PROVIDER;
-  if (provider !== DEFAULT_RERANK_PROVIDER)
-    return;
+  if (!SUPPORTED_RERANK_PROVIDERS.includes(provider)) {
+    throw new Error(`Unsupported rerank provider "${provider}"; supported providers: ${SUPPORTED_RERANK_PROVIDERS.join(", ")}`);
+  }
   return new OpenRouterReranker(config);
 }
 
@@ -7794,8 +7795,8 @@ class OpenRouterReranker {
       sdkOptions.timeoutMs = options.timeoutMs;
     const sdk = new OpenRouter(sdkOptions);
     this.client = {
-      rerank: async (request) => {
-        const response = await sdk.rerank.rerank(request);
+      rerank: async (request, requestOptions) => {
+        const response = await sdk.rerank.rerank(request, requestOptions);
         if (typeof response === "string")
           throw new Error(response);
         return response;
@@ -7824,7 +7825,7 @@ class OpenRouterReranker {
     };
     if (options.topN !== undefined)
       requestBody.topN = options.topN;
-    const response = await this.client.rerank({ requestBody });
+    const response = await this.client.rerank({ requestBody }, { signal: options.signal });
     const ordered = Array.isArray(response?.results) ? response.results : [];
     const seen = new Set;
     const reranked = [];
@@ -7854,8 +7855,10 @@ class OpenRouterReranker {
     return reranked;
   }
 }
-var DEFAULT_RERANK_MODEL = "voyageai/rerank-3-lite", DEFAULT_RERANK_PROVIDER = "openrouter", DEFAULT_RERANK_API_KEY_ENV = "OPENROUTER_API_KEY";
-var init_rerank = () => {};
+var DEFAULT_RERANK_MODEL = "voyageai/rerank-3-lite", DEFAULT_RERANK_PROVIDER = "openrouter", DEFAULT_RERANK_API_KEY_ENV = "OPENROUTER_API_KEY", SUPPORTED_RERANK_PROVIDERS;
+var init_rerank = __esm(() => {
+  SUPPORTED_RERANK_PROVIDERS = [DEFAULT_RERANK_PROVIDER];
+});
 
 // src/web/search/credentials.ts
 function envCredential(...names) {
@@ -7911,392 +7914,9 @@ var init_model_auth = __esm(() => {
   };
 });
 
-// src/filesystem/cloud-placeholder.ts
-import { execFile as execFile2 } from "node:child_process";
-import { lstat } from "node:fs/promises";
-import { dirname as dirname10, relative as relative6, sep as sep7 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-function pathLooksLikeCloudRoot(target) {
-  const normalized = target.replaceAll("\\", "/");
-  return MAC_CLOUD_PATH_MARKERS.some((marker) => normalized.includes(marker)) || WINDOWS_CLOUD_PATH_MARKERS.some((marker) => normalized.toLowerCase().includes(marker.toLowerCase()));
-}
-async function classifyFilesystemRoot(target) {
-  if (pathLooksLikeCloudRoot(target)) {
-    return { kind: "file-provider", reason: "path-marker", provider: cloudProviderFromPath(target) };
-  }
-  if (process.platform === "darwin")
-    return classifyDarwinRoot(target);
-  if (process.platform === "win32")
-    return classifyWindowsRoot(target);
-  return { kind: "local", reason: "local" };
-}
-async function isDatalessPlaceholder(target) {
-  if (process.platform === "darwin") {
-    try {
-      const { stdout } = await execFileAsync("/usr/bin/stat", ["-f", "%f", target], { timeout: 2000 });
-      const flags = Number.parseInt(stdout.trim(), 16);
-      return Number.isFinite(flags) && (flags & UF_DATALESS) !== 0;
-    } catch {
-      return false;
-    }
-  }
-  if (process.platform === "win32") {
-    const attributes = await windowsFileAttributes(target);
-    return attributes !== undefined && (attributes & WINDOWS_FILE_ATTRIBUTE_OFFLINE) !== 0 && (attributes & (WINDOWS_FILE_ATTRIBUTE_RECALL_ON_OPEN | WINDOWS_FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS)) !== 0;
-  }
-  return false;
-}
-async function classifyDarwinRoot(target) {
-  let cursor = target;
-  for (let depth = 0;depth < 8; depth += 1) {
-    const provider = await readFileProviderDomain(cursor);
-    if (provider !== undefined)
-      return { kind: "file-provider", reason: "file-provider-xattr", provider };
-    const parent = dirname10(cursor);
-    if (parent === cursor)
-      break;
-    cursor = parent;
-  }
-  return { kind: "local", reason: "local" };
-}
-async function classifyWindowsRoot(target) {
-  const attributes = await windowsFileAttributes(target);
-  if (attributes !== undefined && (attributes & WINDOWS_FILE_ATTRIBUTE_OFFLINE) !== 0 && (attributes & (WINDOWS_FILE_ATTRIBUTE_RECALL_ON_OPEN | WINDOWS_FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS)) !== 0) {
-    return { kind: "file-provider", reason: "placeholder-attribute", provider: "windows-cloud-files" };
-  }
-  if (await windowsCloudVolume(target)) {
-    return { kind: "file-provider", reason: "cloud-volume", provider: "windows-cloud-volume" };
-  }
-  return { kind: "local", reason: "local" };
-}
-async function windowsFileAttributes(target) {
-  try {
-    const script = `(Get-Item -LiteralPath ${quotePowerShell(target)} -Force).Attributes.value__`;
-    const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
-      timeout: 2000
-    });
-    const value = Number.parseInt(stdout.trim(), 10);
-    return Number.isFinite(value) ? value : undefined;
-  } catch {
-    return;
-  }
-}
-async function windowsCloudVolume(target) {
-  try {
-    const root = /^[A-Za-z]:/.test(target) ? `${target.slice(0, 2)}\\` : target;
-    const script = `Get-Volume -DriveLetter '${root[0]}' -ErrorAction SilentlyContinue | ` + "Select-Object -Property FileSystem,FileSystemLabel | ConvertTo-Json -Compress";
-    const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
-      timeout: 2000
-    });
-    return /drivefs|google drive|onedrive|cloud/i.test(stdout);
-  } catch {
-    return false;
-  }
-}
-async function readFileProviderDomain(target) {
-  try {
-    await lstat(target);
-    const { stdout } = await execFileAsync("/usr/bin/xattr", ["-p", FILE_PROVIDER_XATTR, target], {
-      timeout: 2000
-    });
-    const value = stdout.trim();
-    return value.length > 0 ? value : undefined;
-  } catch {
-    return;
-  }
-}
-function cloudProviderFromPath(target) {
-  const lower = target.toLowerCase();
-  if (lower.includes("googledrive") || lower.includes("google drive") || lower.includes("drivefs"))
-    return "google-drive";
-  if (lower.includes("onedrive"))
-    return "onedrive";
-  if (lower.includes("mobile documents") || lower.includes("clouddocs"))
-    return "icloud";
-  return "file-provider";
-}
-function quotePowerShell(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-var execFileAsync, UF_DATALESS = 32768, FILE_PROVIDER_XATTR = "com.apple.file-provider-domain-id", WINDOWS_FILE_ATTRIBUTE_OFFLINE = 4096, WINDOWS_FILE_ATTRIBUTE_RECALL_ON_OPEN = 262144, WINDOWS_FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS = 4194304, MAC_CLOUD_PATH_MARKERS, WINDOWS_CLOUD_PATH_MARKERS;
-var init_cloud_placeholder = __esm(() => {
-  execFileAsync = promisify2(execFile2);
-  MAC_CLOUD_PATH_MARKERS = ["/Library/CloudStorage/", "/Library/Mobile Documents/"];
-  WINDOWS_CLOUD_PATH_MARKERS = [
-    "\\OneDrive",
-    "/OneDrive",
-    "\\Google Drive",
-    "/Google Drive",
-    "\\GoogleDriveFS",
-    "/GoogleDriveFS",
-    "\\My Drive",
-    "/My Drive",
-    "\\Shared drives",
-    "/Shared drives"
-  ];
-});
-
-// src/agent/bash-tool.ts
-import { spawn as spawn9 } from "node:child_process";
-import { Type as Type2 } from "typebox";
-function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve({
-        output: "",
-        exitCode: undefined,
-        aborted: true,
-        terminationFailed: false,
-        timedOut: false,
-        truncated: false
-      });
-      return;
-    }
-    const shell = process.platform === "win32" ? "bash.exe" : "/bin/bash";
-    const child = spawn9(shell, ["-c", command], {
-      cwd,
-      detached: process.platform !== "win32",
-      windowsHide: true
-    });
-    const chunks = [];
-    let total = 0;
-    let truncated = false;
-    let timedOut = false;
-    let aborted = false;
-    let settled = false;
-    let killGraceTimer;
-    let terminationRequested = false;
-    let terminationStarted = false;
-    let terminationSettled = false;
-    let terminationFailed = false;
-    let pendingExitCode;
-    const collect = (data) => {
-      if (total >= maxOutputBytes) {
-        truncated = true;
-        return;
-      }
-      const remaining = maxOutputBytes - total;
-      if (data.length > remaining) {
-        chunks.push(data.subarray(0, remaining));
-        total = maxOutputBytes;
-        truncated = true;
-      } else {
-        chunks.push(data);
-        total += data.length;
-      }
-    };
-    child.stdout?.on("data", collect);
-    child.stderr?.on("data", collect);
-    const finish = (exitCode) => {
-      if (settled)
-        return;
-      if (terminationRequested && !terminationSettled) {
-        pendingExitCode = exitCode;
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      if (killGraceTimer !== undefined)
-        clearTimeout(killGraceTimer);
-      signal?.removeEventListener("abort", onAbort);
-      resolve({
-        output: Buffer.concat(chunks).toString("utf8"),
-        exitCode,
-        aborted,
-        terminationFailed,
-        timedOut,
-        truncated
-      });
-    };
-    const killDirectChild = () => {
-      try {
-        return child.kill("SIGKILL");
-      } catch {
-        return false;
-      }
-    };
-    const killProcessTree = async () => {
-      if (child.pid === undefined)
-        return true;
-      if (process.platform === "win32") {
-        return await new Promise((resolve) => {
-          const killer = spawn9("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
-          let completed = false;
-          const graceTimer = setTimeout(() => {
-            if (completed)
-              return;
-            completed = true;
-            killer.kill();
-            resolve(killDirectChild());
-          }, KILL_EXIT_GRACE_MS);
-          const finishKill = (success) => {
-            if (completed)
-              return;
-            completed = true;
-            clearTimeout(graceTimer);
-            if (!success)
-              killDirectChild();
-            resolve(success);
-          };
-          killer.on("error", () => finishKill(false));
-          killer.on("close", (code) => finishKill(code === 0));
-        });
-      }
-      try {
-        process.kill(-child.pid, "SIGKILL");
-        return true;
-      } catch {
-        killDirectChild();
-        return false;
-      }
-    };
-    const releaseAfterKill = async () => {
-      if (terminationStarted)
-        return;
-      terminationStarted = true;
-      const killed = await killProcessTree();
-      terminationSettled = true;
-      terminationFailed = !killed;
-      child.stdout?.destroy();
-      child.stderr?.destroy();
-      killGraceTimer = setTimeout(() => finish(undefined), KILL_EXIT_GRACE_MS);
-      if (pendingExitCode !== undefined)
-        finish(pendingExitCode);
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      terminationRequested = true;
-      releaseAfterKill();
-    }, timeoutMs);
-    const onAbort = () => {
-      aborted = true;
-      terminationRequested = true;
-      releaseAfterKill();
-    };
-    if (signal) {
-      if (signal.aborted)
-        onAbort();
-      else
-        signal.addEventListener("abort", onAbort, { once: true });
-    }
-    child.on("error", () => finish(undefined));
-    child.on("close", (code) => finish(code === null ? undefined : code));
-  });
-}
-function createBashTool(options) {
-  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
-  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
-  return {
-    name: BASH_TOOL_NAME,
-    label: "Bash",
-    description: "Run a shell command to explore and read the document collection (ls, find, grep, cat, head, sed, rg). Returns combined stdout/stderr.",
-    parameters: bashSchema,
-    async execute(_toolCallId, params, signal) {
-      const command = String(params.command ?? "").trim();
-      if (command.length === 0) {
-        return {
-          content: [{ type: "text", text: "Command was empty; nothing was run." }],
-          details: {
-            method: "bash",
-            command: "",
-            aborted: false,
-            exitCode: undefined,
-            terminationFailed: false,
-            timedOut: false,
-            truncated: false
-          }
-        };
-      }
-      const cwd = typeof params.cwd === "string" && params.cwd.length > 0 ? params.cwd : options.cwd;
-      if (CLOUD_CONTENT_COMMAND.test(command)) {
-        const classification = await classifyFilesystemRoot(cwd);
-        if (classification.kind === "file-provider") {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "AUTORAG_CLOUD_PLACEHOLDER_BLOCKED: content access under a cloud placeholder root was refused to prevent remote hydration. " + "Use the configured cloud-drive datasource or a materialized local file."
-              }
-            ],
-            details: {
-              method: "bash",
-              command,
-              aborted: false,
-              exitCode: undefined,
-              terminationFailed: false,
-              timedOut: false,
-              truncated: false
-            }
-          };
-        }
-        if (await isDatalessPlaceholder(cwd)) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "AUTORAG_CLOUD_PLACEHOLDER_BLOCKED: the working path is a data-less cloud placeholder. " + "Use the configured cloud-drive datasource or materialize the file first."
-              }
-            ],
-            details: {
-              method: "bash",
-              command,
-              aborted: false,
-              exitCode: undefined,
-              terminationFailed: false,
-              timedOut: false,
-              truncated: false
-            }
-          };
-        }
-      }
-      const timeoutMs = typeof params.timeoutMs === "number" && params.timeoutMs > 0 ? params.timeoutMs : defaultTimeout;
-      const run = await runCommand(command, cwd, timeoutMs, maxOutputBytes, signal);
-      const parts = [];
-      parts.push(run.output.length > 0 ? run.output : run.aborted ? "(command aborted)" : "(no output)");
-      if (run.timedOut)
-        parts.push(`
-(command timed out after ${timeoutMs}ms and was killed)`);
-      if (run.truncated)
-        parts.push(`
-(output truncated at ${maxOutputBytes} bytes)`);
-      if (run.exitCode !== undefined && run.exitCode !== 0 && !run.timedOut) {
-        parts.push(`
-(exit code ${run.exitCode})`);
-      }
-      if (run.terminationFailed)
-        parts.push(`
-(process termination failed)`);
-      return {
-        content: [{ type: "text", text: parts.join("") }],
-        details: {
-          method: "bash",
-          command,
-          aborted: run.aborted,
-          exitCode: run.exitCode,
-          terminationFailed: run.terminationFailed,
-          timedOut: run.timedOut,
-          truncated: run.truncated
-        }
-      };
-    }
-  };
-}
-var BASH_TOOL_NAME = "bash", DEFAULT_TIMEOUT_MS6 = 120000, DEFAULT_MAX_OUTPUT_BYTES = 131072, KILL_EXIT_GRACE_MS = 5000, bashSchema, CLOUD_CONTENT_COMMAND;
-var init_bash_tool = __esm(() => {
-  init_cloud_placeholder();
-  bashSchema = Type2.Object({
-    command: Type2.String({
-      description: "Shell command to run (bash -c). Use standard tools like ls, find, grep, cat, head, sed, rg."
-    }),
-    cwd: Type2.Optional(Type2.String({ description: "Working directory for the command. Defaults to the configured workspace root." })),
-    timeoutMs: Type2.Optional(Type2.Integer({ description: "Optional timeout in milliseconds for this command." }))
-  });
-  CLOUD_CONTENT_COMMAND = /\b(?:rg|ripgrep|grep|egrep|fgrep|cat|less|more|head|tail|sed|awk)\b/i;
-});
-
 // src/agent/datasource-skill.ts
 import { formatSkillsForSystemPrompt } from "@earendil-works/pi-agent-core";
-import { Type as Type3 } from "typebox";
+import { Type as Type2 } from "typebox";
 function datasourceSkillLocation(name) {
   return `datasource://${name}`;
 }
@@ -8342,15 +7962,15 @@ function createLoadDatasourceSkillTool(provider) {
 }
 var LOAD_DATASOURCE_SKILL_TOOL_NAME = "load_datasource_skill", loadDatasourceSkillSchema;
 var init_datasource_skill = __esm(() => {
-  loadDatasourceSkillSchema = Type3.Object({
-    name: Type3.String({
+  loadDatasourceSkillSchema = Type2.Object({
+    name: Type2.String({
       description: "Datasource skill name from the available skills list to load full instructions for."
     })
   });
 });
 
 // src/agent/dupey-tool.ts
-import { Type as Type4 } from "typebox";
+import { Type as Type3 } from "typebox";
 function createScanDuplicateDocumentsTool(provider) {
   return {
     name: SCAN_DUPLICATE_DOCUMENTS_TOOL_NAME,
@@ -8469,11 +8089,11 @@ function formatScore(value) {
 }
 var SCAN_DUPLICATE_DOCUMENTS_TOOL_NAME = "scan_duplicate_documents", MAX_RENDERED_FAMILIES = 200, MAX_RENDERED_MEMBERS = 50, scanDuplicateDocumentsSchema;
 var init_dupey_tool = __esm(() => {
-  scanDuplicateDocumentsSchema = Type4.Object({});
+  scanDuplicateDocumentsSchema = Type3.Object({});
 });
 
 // src/agent/emit-results-tool.ts
-import { Type as Type5 } from "typebox";
+import { Type as Type4 } from "typebox";
 function createEmitResultsTool(capture) {
   return {
     name: EMIT_AUTORAG_RESULTS_TOOL_NAME,
@@ -8526,55 +8146,55 @@ function createEmitResultsTool(capture) {
 }
 var EMIT_AUTORAG_RESULTS_TOOL_NAME = "emit_autorag_results", evidenceRefSchema, emitResultsSchema;
 var init_emit_results_tool = __esm(() => {
-  evidenceRefSchema = Type5.Object({
-    method: Type5.String({ description: "Retrieval method namespace for this evidence chunk" }),
-    source: Type5.String({ description: "Internal opaque source identifier for this evidence chunk" }),
-    excerpt: Type5.Optional(Type5.String({ description: "Evidence excerpt used for stable ID normalization" })),
-    content: Type5.Optional(Type5.String({ description: "Evidence content used for stable ID normalization" })),
-    retrievalResultId: Type5.Optional(Type5.String({ description: "Backend retrieval ID when path-opaque and stable" })),
-    chunkIndex: Type5.Optional(Type5.Integer({ description: "Chunk index, if available" })),
-    lineNumber: Type5.Optional(Type5.Integer({ description: "Line number, if available" })),
-    stableEvidenceId: Type5.Optional(Type5.String({ description: "Stable evidence ID, if already normalized" })),
-    retrieverMix: Type5.Optional(Type5.Array(Type5.String({ maxLength: 64 }), {
+  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: Type5.Optional(Type5.String({ description: "Parser that produced this evidence", maxLength: 120 })),
-    documentType: Type5.Optional(Type5.String({ description: "Document type, if known", maxLength: 120 })),
-    documentArea: Type5.Optional(Type5.String({ description: "Document collection area, if known", maxLength: 120 })),
-    evidenceType: Type5.Optional(Type5.String({ description: "Evidence type, if known", maxLength: 120 })),
-    evidenceLocation: Type5.Optional(Type5.String({ description: "Human-readable evidence location", maxLength: 120 })),
-    confidence: Type5.Optional(Type5.Number({ description: "Evidence confidence, 0..1", minimum: 0, maximum: 1 }))
+    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 }))
   });
-  emitResultsSchema = Type5.Object({
-    answer: Type5.String({
+  emitResultsSchema = Type4.Object({
+    answer: 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."
     }),
-    results: Type5.Array(Type5.Object({
-      number: Type5.Integer({ description: "1-based result number" }),
-      title: Type5.String({ description: "Short name of the curated knowledge unit" }),
-      summary: Type5.String({ description: "Key insight: purpose, details, and line range" }),
-      evidence: Type5.Array(Type5.Object({
-        excerpt: Type5.String({ description: "Supporting excerpt" }),
-        lineNumber: Type5.Optional(Type5.Integer({ description: "Line number of the excerpt, if known" }))
+    results: Type4.Array(Type4.Object({
+      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: Type5.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 })
+      confidence: Type4.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 })
     }), { description: "Numbered curated knowledge units." }),
-    mapping: Type5.Array(Type5.Object({
-      number: Type5.Integer({ description: "Matches the result number this entry maps" }),
-      source: Type5.String({ description: "Source identifier — a real file path or a datasource id" }),
-      method: Type5.String({ description: "Retrieval method or tool that produced the source" }),
-      content: Type5.String({ description: "Raw content snippet for feedback tracking" }),
-      evidenceRefs: Type5.Optional(Type5.Array(evidenceRefSchema, {
+    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 for feedback tracking" }),
+      evidenceRefs: Type4.Optional(Type4.Array(evidenceRefSchema, {
         description: "Hidden evidence chunk references supporting this curated result"
       }))
     }), { description: "Internal number -> source/method mapping for feedback. One entry per result number." }),
-    warnings: Type5.Optional(Type5.Array(Type5.String(), { description: "Optional warnings about this result set" }))
+    warnings: Type4.Optional(Type4.Array(Type4.String(), { description: "Optional warnings about this result set" }))
   });
 });
 
 // src/agent/everything-search-tool.ts
-import { Type as Type6 } from "typebox";
+import { Type as Type5 } from "typebox";
 function createEverythingSearchTool(provider) {
   return {
     name: EVERYTHING_SEARCH_TOOL_NAME,
@@ -8626,28 +8246,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 = Type6.Object({
-    query: Type6.String({
+  everythingSearchSchema = Type5.Object({
+    query: Type5.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: Type6.Optional(Type6.Boolean({ description: "Treat query as a regular expression." })),
-    matchCase: Type6.Optional(Type6.Boolean()),
-    matchPath: Type6.Optional(Type6.Boolean({ description: "Match against the full path instead of the name." })),
-    wholeWord: Type6.Optional(Type6.Boolean()),
-    kind: Type6.Optional(Type6.Union([Type6.Literal("files"), Type6.Literal("folders")])),
-    path: Type6.Optional(Type6.String({ description: "Absolute folder to search within." })),
-    sort: Type6.Optional(Type6.Union([
-      Type6.Literal("name-ascending"),
-      Type6.Literal("name-descending"),
-      Type6.Literal("path-ascending"),
-      Type6.Literal("path-descending"),
-      Type6.Literal("size-ascending"),
-      Type6.Literal("size-descending"),
-      Type6.Literal("date-modified-ascending"),
-      Type6.Literal("date-modified-descending")
+    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")
     ])),
-    offset: Type6.Optional(Type6.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
-    maxResults: Type6.Optional(Type6.Integer({
+    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_RESULTS3}, cap ${MAX_RESULTS_CAP2}).`
     }))
@@ -8655,7 +8275,7 @@ var init_everything_search_tool = __esm(() => {
 });
 
 // src/agent/fast-answer-tool.ts
-import { Type as Type7 } from "typebox";
+import { Type as Type6 } from "typebox";
 function createEmitFastAnswerTool(capture) {
   return {
     name: EMIT_FAST_ANSWER_TOOL_NAME,
@@ -8689,29 +8309,29 @@ function createEmitFastAnswerTool(capture) {
 }
 var EMIT_FAST_ANSWER_TOOL_NAME = "emit_fast_answer", fastAnswerSchema;
 var init_fast_answer_tool = __esm(() => {
-  fastAnswerSchema = Type7.Object({
-    answer: Type7.String({
+  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."
     }),
-    results: Type7.Array(Type7.Object({
-      number: Type7.Integer({ description: "1-based result number" }),
-      title: Type7.String({ description: "Short name of the knowledge unit" }),
-      summary: Type7.String({ description: "Key insight backing the first answer" }),
-      evidence: Type7.Optional(Type7.Array(Type7.Object({
-        excerpt: Type7.String({ description: "Supporting excerpt" }),
-        lineNumber: Type7.Optional(Type7.Integer({ description: "Line number of the excerpt, if known" }))
+    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: Type7.Optional(Type7.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 }))
+      confidence: Type6.Optional(Type6.Number({ description: "Confidence in this result, 0..1", minimum: 0, maximum: 1 }))
     }), { description: "Numbered knowledge units backing the first answer." }),
-    sources: Type7.Optional(Type7.Array(Type7.Object({
-      number: Type7.Integer({ description: "Matches the result number this source belongs to" }),
-      source: Type7.String({ description: "Source identifier — a real file path or a datasource id" })
+    sources: Type6.Optional(Type6.Array(Type6.Object({
+      number: Type6.Integer({ description: "Matches the result number this source belongs to" }),
+      source: Type6.String({ description: "Source identifier — a real file path or a datasource id" })
     }), { description: "Optional number -> source mapping for the first answer." }))
   });
 });
 
 // src/agent/fsearch-search-tool.ts
-import { Type as Type8 } from "typebox";
+import { Type as Type7 } from "typebox";
 function createFSearchSearchTool(provider) {
   return {
     name: FSEARCH_SEARCH_TOOL_NAME,
@@ -8767,27 +8387,27 @@ ${lines.join(`
 }
 var FSEARCH_SEARCH_TOOL_NAME = "fsearch_search", MAX_RESULTS_CAP3 = 1000, DEFAULT_MAX_RESULTS4 = 100, fsearchSearchSchema;
 var init_fsearch_search_tool = __esm(() => {
-  fsearchSearchSchema = Type8.Object({
-    query: Type8.String({
+  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: Type8.Optional(Type8.Boolean({ description: "Treat query as a regular expression." })),
-    matchCase: Type8.Optional(Type8.Boolean()),
-    matchPath: Type8.Optional(Type8.Boolean({ description: "Match against the full path instead of the name." })),
-    kind: Type8.Optional(Type8.Union([Type8.Literal("files"), Type8.Literal("folders")])),
-    path: Type8.Optional(Type8.String({ description: "Absolute folder to search within." })),
-    sort: Type8.Optional(Type8.Union([
-      Type8.Literal("name-ascending"),
-      Type8.Literal("name-descending"),
-      Type8.Literal("path-ascending"),
-      Type8.Literal("path-descending"),
-      Type8.Literal("size-ascending"),
-      Type8.Literal("size-descending"),
-      Type8.Literal("date-modified-ascending"),
-      Type8.Literal("date-modified-descending")
+    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: Type8.Optional(Type8.Integer({ minimum: 0, description: "Skip this many results (pagination)." })),
-    maxResults: Type8.Optional(Type8.Integer({
+    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}).`
     }))
@@ -8795,7 +8415,7 @@ var init_fsearch_search_tool = __esm(() => {
 });
 
 // src/agent/jikji-find-tool.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type8 } from "typebox";
 function createJikjiFindTool(provider) {
   return {
     name: JIKJI_FIND_TOOL_NAME,
@@ -8916,10 +8536,10 @@ function formatDirective(policy) {
 }
 var JIKJI_FIND_TOOL_NAME = "jikji_find", jikjiFindSchema;
 var init_jikji_find_tool = __esm(() => {
-  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 = Type8.Object({
+    query: Type8.String({ description: "Query for Jikji local file discovery." }),
+    topK: Type8.Optional(Type8.Integer({ description: "Maximum number of answer paths / candidates to return." })),
+    first: Type8.Optional(Type8.Boolean({ description: "Return only the first/best answer." }))
   });
 });
 
@@ -8981,7 +8601,7 @@ import {
   watch,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname11, join as join21 } from "node:path";
+import { dirname as dirname10, join as join21 } from "node:path";
 function requestsDir(workspacePath) {
   return join21(workspacePath, P2P_DIR, "requests");
 }
@@ -8998,7 +8618,7 @@ function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function atomicWrite(path, value) {
-  mkdirSync11(dirname11(path), { recursive: true });
+  mkdirSync11(dirname10(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
   writeFileSync10(tempPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -9404,7 +9024,7 @@ var init_egress_gate = __esm(() => {
 
 // src/p2p/policy.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename10, dirname as dirname12, join as join22, resolve as resolve12 } from "node:path";
+import { basename as basename10, dirname as dirname11, join as join22, resolve as resolve12 } from "node:path";
 import { parse as parseToml } from "smol-toml";
 function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -9742,7 +9362,7 @@ class PolicyStore {
   }
   persistSeenSources() {
     try {
-      mkdirSync12(dirname12(this.seenSourcesPath), { recursive: true });
+      mkdirSync12(dirname11(this.seenSourcesPath), { recursive: true });
       writeFileSync11(this.seenSourcesPath, `${JSON.stringify({
         sources: [...this.seenSources].sort(),
         pending: [...this.pendingSources].sort()
@@ -9888,57 +9508,57 @@ var init_policy = __esm(() => {
 });
 
 // src/p2p/wire.ts
-import { Type as Type10 } from "typebox";
+import { Type as Type9 } 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 = Type9.Union([
+    Type9.Literal("auth-error"),
+    Type9.Literal("replay-rejected"),
+    Type9.Literal("rate-limited"),
+    Type9.Literal("injection-detected"),
+    Type9.Literal("policy-denied"),
+    Type9.Literal("queue-full"),
+    Type9.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 = Type9.Object({
+    code: Type9.String({ minLength: 1, description: "Diagnostic or refusal code" }),
+    message: Type9.String({ description: "Human-readable diagnostic message" })
   });
-  PeerFileEntrySchema = Type10.Object({
-    source: Type10.String({
+  PeerFileEntrySchema = Type9.Object({
+    source: Type9.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: Type9.String({ description: "Base64-encoded file content" }),
+    redacted: Type9.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 = Type9.Object({
+    number: Type9.Integer({ minimum: 1, description: "1-based result number" }),
+    title: Type9.String({ minLength: 1, description: "Short title of the result" }),
+    summary: Type9.String({ description: "Key insight summary" }),
+    source: Type9.String({
       description: "Canonical retrieval source identifier"
     }),
-    excerpt: Type10.String({ description: "Supporting excerpt" })
+    excerpt: Type9.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 = Type9.Object({
+    v: Type9.Literal(1, { description: "Protocol version" }),
+    query: Type9.String({ minLength: 1, maxLength: 4096, description: "Search query (max 4096 chars)" }),
+    topK: Type9.Optional(Type9.Integer({ minimum: 1, maximum: 20, description: "Max results to return (max 20)" })),
+    scope: Type9.Optional(Type9.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 = Type9.Object({
+    v: Type9.Literal(1, { description: "Protocol version" }),
+    status: Type9.Union([Type9.Literal("ok"), Type9.Literal("rejected")], {
       description: "Response status"
     }),
-    answer: Type10.String({ description: "Curated answer text" }),
-    results: Type10.Array(PeerResultEntrySchema, {
+    answer: Type9.String({ description: "Curated answer text" }),
+    results: Type9.Array(PeerResultEntrySchema, {
       description: "Curated result entries with opaque source ids"
     }),
-    files: Type10.Array(PeerFileEntrySchema, {
+    files: Type9.Array(PeerFileEntrySchema, {
       description: "Attached original files with opaque source ids"
     }),
-    diagnostics: Type10.Array(PeerDiagnosticSchema, {
+    diagnostics: Type9.Array(PeerDiagnosticSchema, {
       description: "Diagnostic messages (degraded-mode, rejection reasons, etc.)"
     })
   });
@@ -9947,7 +9567,7 @@ var init_wire = __esm(() => {
 // src/p2p/simplex-query-store.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync17, mkdirSync as mkdirSync13, readdirSync as readdirSync5, readFileSync as readFileSync14, renameSync as renameSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join23 } from "node:path";
+import { dirname as dirname12, join as join23 } from "node:path";
 import { Value } from "typebox/value";
 function statePath(workspacePath, directory, id) {
   return join23(workspacePath, QUERY_DIR, directory, `${id}.json`);
@@ -9956,7 +9576,7 @@ function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function atomicWrite2(path, value) {
-  mkdirSync13(dirname13(path), { recursive: true });
+  mkdirSync13(dirname12(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   writeFileSync12(tempPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -10185,7 +9805,7 @@ var init_simplex_query_store = __esm(() => {
 // src/p2p/simplex-server.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join24 } from "node:path";
-import { Type as Type11 } from "typebox";
+import { Type as Type10 } 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));
@@ -10499,11 +10119,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 = Type10.Object({
+    v: Type10.Literal(1, { description: "Envelope version" }),
+    kind: Type10.Union([Type10.Literal("query"), Type10.Literal("response")], { description: "Payload kind" }),
+    id: Type10.String({ minLength: 1, maxLength: 128, description: "Correlation id" }),
+    payload: Type10.Unknown({ description: "PeerQueryRequest or PeerQueryResponse" })
   });
   TARGET_TOKEN_PATTERN = /[\p{L}\p{N}]+/gu;
   PEERS_DIR = join24(".autorag", "p2p");
@@ -10516,7 +10136,7 @@ var init_simplex_server = __esm(() => {
 });
 
 // src/agent/peer-target-tool.ts
-import { Type as Type12 } from "typebox";
+import { Type as Type11 } from "typebox";
 function createRecommendPeerTargetsTool(workspacePath) {
   return {
     name: RECOMMEND_PEER_TARGETS_TOOL_NAME,
@@ -10549,13 +10169,212 @@ 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 = Type11.Object({
+    query: Type11.String({ description: "Question or topic to match against local peer personas." })
+  });
+});
+
+// src/agent/pi-session.ts
+import { join as join25 } from "node:path";
+import { streamSimple as compatStreamSimple } from "@earendil-works/pi-ai/compat";
+import {
+  createAgentSession,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  DefaultResourceLoader,
+  getAgentDir,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+function toToolDefinition(tool) {
+  return {
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters,
+    ...tool.prepareArguments === undefined ? {} : { prepareArguments: tool.prepareArguments },
+    execute: async (toolCallId, params, signal, onUpdate) => {
+      return tool.execute(toolCallId, params, signal, onUpdate);
+    }
+  };
+}
+function modelConfig(model, configuredApiKey) {
+  return {
+    name: model.name,
+    baseUrl: model.baseUrl,
+    api: model.api,
+    ...configuredApiKey === undefined ? {} : { apiKey: configuredApiKey },
+    authHeader: false,
+    streamSimple: (requestModel, context, options) => compatStreamSimple(requestModel, context, {
+      ...options,
+      ...configuredApiKey === EMBEDDED_AUTH_MARKER ? { apiKey: undefined } : {}
+    }),
+    models: [
+      {
+        id: model.id,
+        name: model.name,
+        reasoning: model.reasoning,
+        input: [...model.input],
+        cost: model.cost,
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+        ...model.thinkingLevelMap === undefined ? {} : { thinkingLevelMap: model.thinkingLevelMap }
+      }
+    ]
+  };
+}
+async function configureModelRuntime(modelRuntime, model, apiKey, providerApiKeys) {
+  if (model !== undefined) {
+    const configuredKey = apiKey ?? providerApiKeys?.[model.provider];
+    if (modelRuntime.getModel(model.provider, model.id) === undefined) {
+      modelRuntime.registerProvider(model.provider, modelConfig(model, configuredKey ?? EMBEDDED_AUTH_MARKER));
+    }
+  }
+  const keys = new Map;
+  if (model !== undefined && apiKey !== undefined)
+    keys.set(model.provider, apiKey);
+  for (const [provider, key] of Object.entries(providerApiKeys ?? {}))
+    keys.set(provider, key);
+  for (const [provider, key] of keys)
+    await modelRuntime.setRuntimeApiKey(provider, key);
+}
+function createAutoRAGExtension(getSystemPrompt, contextTransform) {
+  return (pi) => {
+    pi.on("before_agent_start", () => ({ systemPrompt: getSystemPrompt() }));
+    if (contextTransform !== undefined) {
+      pi.on("context", async (event) => ({ messages: await contextTransform(event.messages) }));
+    }
+  };
+}
+function createAutoRAGInteractiveExtension(getSystemPrompt, contextTransform, onQuery) {
+  return (pi) => {
+    pi.on("before_agent_start", () => ({ systemPrompt: getSystemPrompt() }));
+    if (contextTransform !== undefined) {
+      pi.on("context", async (event) => ({ messages: await contextTransform(event.messages) }));
+    }
+    pi.on("input", async (event) => {
+      const query = event.text.trim();
+      if (event.source !== "interactive" || query.length === 0 || query.startsWith("/"))
+        return;
+      try {
+        await onQuery(query, pi);
+      } catch (error) {
+        pi.sendMessage({
+          customType: "autorag.error",
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          display: true
+        });
+      }
+      return { action: "handled" };
+    });
+  };
+}
+async function createAutoRAGPiSession(options) {
+  const agentDir = options.agentDir ?? getAgentDir();
+  const settingsManager = SettingsManager.create(options.cwd, agentDir);
+  if (settingsManager.getDefaultTools() === undefined) {
+    settingsManager.applyOverrides({ defaultTools: [...PI_BUILTIN_TOOL_NAMES] });
+  }
+  const modelRuntime = await ModelRuntime.create({
+    authPath: join25(agentDir, "auth.json"),
+    modelsPath: join25(agentDir, "models.json")
+  });
+  await configureModelRuntime(modelRuntime, options.model, options.apiKey, options.providerApiKeys);
+  const customTools = [...options.customTools];
+  const resourceLoader = new DefaultResourceLoader({
+    cwd: options.cwd,
+    agentDir,
+    settingsManager,
+    extensionFactories: [createAutoRAGExtension(options.getSystemPrompt, options.contextTransform)],
+    systemPromptOverride: () => options.getSystemPrompt(),
+    appendSystemPromptOverride: () => []
+  });
+  await resourceLoader.reload();
+  const sessionManager = options.sessionPath ? SessionManager.open(options.sessionPath, options.sessionDir, options.cwd) : options.persistSession ? SessionManager.create(options.cwd, options.sessionDir) : SessionManager.inMemory(options.cwd);
+  const customToolNames = customTools.map((tool) => tool.name);
+  const customToolDefinitions = customTools.map(toToolDefinition);
+  const { session } = await createAgentSession({
+    cwd: options.cwd,
+    agentDir,
+    modelRuntime,
+    settingsManager,
+    resourceLoader,
+    sessionManager,
+    model: options.model,
+    customTools: customToolDefinitions,
+    tools: [...PI_BUILTIN_TOOL_NAMES, ...customToolNames],
+    excludeTools: options.remoteSession ? ["edit", "write", "powershell"] : undefined,
+    thinkingLevel: "off"
+  });
+  const initialToolNames = [...new Set([...session.getActiveToolNames(), ...customToolNames])];
+  session.setActiveToolsByName(initialToolNames);
+  return {
+    session,
+    baseToolNames: initialToolNames,
+    sessionFile: session.sessionFile
+  };
+}
+async function createAutoRAGPiInteractiveRuntime(options) {
+  const agentDir = options.agentDir ?? getAgentDir();
+  const settingsManager = SettingsManager.create(options.cwd, agentDir);
+  if (settingsManager.getDefaultTools() === undefined) {
+    settingsManager.applyOverrides({ defaultTools: [...PI_BUILTIN_TOOL_NAMES] });
+  }
+  const modelRuntime = await ModelRuntime.create({
+    authPath: join25(agentDir, "auth.json"),
+    modelsPath: join25(agentDir, "models.json")
   });
+  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 ({
+    cwd,
+    agentDir: runtimeAgentDir,
+    sessionManager: runtimeSessionManager,
+    sessionStartEvent
+  }) => {
+    const services = await createAgentSessionServices({
+      cwd,
+      agentDir: runtimeAgentDir,
+      modelRuntime,
+      settingsManager,
+      resourceLoaderOptions: {
+        extensionFactories: [
+          createAutoRAGInteractiveExtension(options.getSystemPrompt, options.contextTransform, options.onQuery)
+        ],
+        systemPrompt: options.getSystemPrompt(),
+        appendSystemPrompt: []
+      }
+    });
+    const result = await createAgentSessionFromServices({
+      services,
+      sessionManager: runtimeSessionManager,
+      sessionStartEvent,
+      customTools: options.customTools.map(toToolDefinition),
+      tools: [...PI_BUILTIN_TOOL_NAMES, ...options.customTools.map((tool) => tool.name)],
+      excludeTools: options.remoteSession ? ["edit", "write", "powershell"] : undefined
+    });
+    if (options.inactiveToolNames !== undefined && options.inactiveToolNames.length > 0) {
+      const inactive = new Set(options.inactiveToolNames);
+      result.session.setActiveToolsByName(result.session.getActiveToolNames().filter((name) => !inactive.has(name)));
+    }
+    return { ...result, services, diagnostics: services.diagnostics };
+  };
+  const runtime = await createAgentSessionRuntime(createRuntime, {
+    cwd: options.cwd,
+    agentDir,
+    sessionManager
+  });
+  return { runtime, dispose: () => runtime.dispose() };
+}
+var PI_BUILTIN_TOOL_NAMES, EMBEDDED_AUTH_MARKER = "<autorag-embedded-model>";
+var init_pi_session = __esm(() => {
+  PI_BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 });
 
 // src/agent/query-peer-tool.ts
-import { Type as Type13 } from "typebox";
+import { Type as Type12 } from "typebox";
 function failure(alias, message) {
   const details = { method: "query_peer_agent", ok: false, alias, message };
   return { content: [{ type: "text", text: message }], details };
@@ -10660,18 +10479,18 @@ var QUERY_PEER_AGENT_TOOL_NAME = "query_peer_agent", queryPeerAgentSchema;
 var init_query_peer_tool = __esm(() => {
   init_simplex_query_store();
   init_simplex_server();
-  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 = Type12.Object({
+    alias: Type12.String({ minLength: 1 }),
+    query: Type12.String({ minLength: 1, maxLength: 4096 }),
+    topK: Type12.Optional(Type12.Integer({ minimum: 1, maximum: 20 })),
+    scope: Type12.Optional(Type12.String())
   });
 });
 
 // src/agent/refresh-progress.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync16, renameSync as renameSync9, rmSync as rmSync6, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 function readRefreshProgress(root) {
   try {
     const parsed = JSON.parse(readFileSync16(refreshProgressPath(root), "utf8"));
@@ -10685,7 +10504,7 @@ function readRefreshProgress(root) {
 }
 function writeRefreshProgress(root, progress) {
   const path = refreshProgressPath(root);
-  mkdirSync15(dirname14(path), { recursive: true });
+  mkdirSync15(dirname13(path), { recursive: true });
   const temporaryPath = `${path}.${randomUUID7()}.tmp`;
   try {
     writeFileSync14(temporaryPath, `${JSON.stringify(progress, null, 2)}
@@ -10908,7 +10727,7 @@ var init_search_documents = __esm(() => {
 });
 
 // src/agent/search-all-tool.ts
-import { Type as Type14 } from "typebox";
+import { Type as Type13 } from "typebox";
 function createSearchAllDocumentsTool(provider) {
   return {
     name: SEARCH_ALL_DOCUMENTS_TOOL_NAME,
@@ -10961,17 +10780,17 @@ ${rows.join(`
 var SEARCH_ALL_DOCUMENTS_TOOL_NAME = "search_all_documents", searchAllSchema;
 var init_search_all_tool = __esm(() => {
   init_search_documents();
-  searchAllSchema = Type14.Object({
-    query: Type14.String({ description: "Query to search across all configured retrieval methods." }),
-    topK: Type14.Optional(Type14.Integer({
+  searchAllSchema = Type13.Object({
+    query: Type13.String({ description: "Query to search across all configured retrieval methods." }),
+    topK: Type13.Optional(Type13.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: Type13.Optional(Type13.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 Type14 } from "typebox";
 function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => scope) {
   return {
     name: SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME,
@@ -11042,12 +10861,12 @@ ${rows.join(`
 var SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME = "semantic_search_local_docs", searchMinSyncSchema;
 var init_search_minsync_tool = __esm(() => {
   init_search_documents();
-  searchMinSyncSchema = Type15.Object({
-    query: Type15.String({
+  searchMinSyncSchema = Type14.Object({
+    query: Type14.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: Type14.Optional(Type14.Integer({ description: "Maximum number of MinSync semantic chunks to return. Defaults to 50." })),
+    scope: Type14.Optional(Type14.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
   });
 });
 
@@ -11065,7 +10884,7 @@ function datasourceSearchToolName(datasourceId) {
 }
 
 // src/agent/search-single-datasource-tool.ts
-import { Type as Type16 } from "typebox";
+import { Type as Type15 } from "typebox";
 function createSingleDatasourceSearchTools(provider, specs) {
   return specs.map((spec) => createTool(provider, spec));
 }
@@ -11129,10 +10948,10 @@ var singleDatasourceToolName, searchSingleDatasourceSchema;
 var init_search_single_datasource_tool = __esm(() => {
   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 50." })),
-    scope: Type16.Optional(Type16.String({ description: "Optional scope narrowing inside this datasource, e.g. one instance root." }))
+  searchSingleDatasourceSchema = Type15.Object({
+    query: Type15.String({ description: "Query to search within this datasource connection." }),
+    topK: Type15.Optional(Type15.Integer({ description: "Maximum number of chunks to return. Defaults to 50." })),
+    scope: Type15.Optional(Type15.String({ description: "Optional scope narrowing inside this datasource, e.g. one instance root." }))
   });
 });
 
@@ -11645,7 +11464,7 @@ var init_url_target = __esm(() => {
 // src/web/fetch/convert.ts
 import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function combineSignals2(signal, timeoutMs) {
   if (!signal)
     return AbortSignal.timeout(timeoutMs);
@@ -11721,8 +11540,8 @@ async function convertBinaryPayload(buffer, extension, _finalUrl, signal) {
   if (!parser) {
     return { content: "", ok: false, error: `No parser registered for ${ext}` };
   }
-  const tempDir = await mkdtemp2(join25(tmpdir2(), "autorag-fetch-"));
-  const tempPath = join25(tempDir, `payload${ext}`);
+  const tempDir = await mkdtemp2(join26(tmpdir2(), "autorag-fetch-"));
+  const tempPath = join26(tempDir, `payload${ext}`);
   try {
     await writeFile3(tempPath, buffer);
     const input = {
@@ -13281,7 +13100,7 @@ var init_render = __esm(() => {
 });
 
 // src/agent/web-fetch-tool.ts
-import { Type as Type17 } from "typebox";
+import { Type as Type16 } from "typebox";
 function truncateHead(output, maxBytes, maxLines) {
   const lines = output.split(`
 `);
@@ -13378,9 +13197,9 @@ var WEB_FETCH_TOOL_NAME = "web_fetch", FETCH_DEFAULT_MAX_LINES = 300, FETCH_MAX_
 var init_web_fetch_tool = __esm(() => {
   init_render();
   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 = Type16.Object({
+    url: Type16.String({ description: "The http(s) URL to fetch and read." }),
+    raw: Type16.Optional(Type16.Boolean({ description: "Return the raw response body without markdown rendering or formatting." }))
   });
 });
 
@@ -16900,7 +16719,7 @@ var init_search = __esm(() => {
 });
 
 // src/agent/web-search-tool.ts
-import { Type as Type18 } from "typebox";
+import { Type as Type17 } from "typebox";
 function createWebSearchTool(options = {}) {
   return {
     name: WEB_SEARCH_TOOL_NAME,
@@ -16970,24 +16789,23 @@ function createWebSearchTool(options = {}) {
 var WEB_SEARCH_TOOL_NAME = "web_search", webSearchSchema;
 var init_web_search_tool = __esm(() => {
   init_search();
-  webSearchSchema = Type18.Object({
-    query: Type18.String({
+  webSearchSchema = Type17.Object({
+    query: Type17.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: Type17.Optional(Type17.Union([Type17.Literal("day"), Type17.Literal("week"), Type17.Literal("month"), Type17.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: Type17.Optional(Type17.Integer({ description: "Maximum number of results to return." })),
+    num_search_results: Type17.Optional(Type17.Integer({ description: "Alias for limit (result count hint)." }))
   });
 });
 
 // src/agent/agent.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { existsSync as existsSync20, watch as fsWatch, mkdirSync as mkdirSync16, realpathSync as realpathSync5, statSync, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename11, dirname as dirname15, join as join26, resolve as resolve13 } from "node:path";
-import { Agent } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
+import { basename as basename11, dirname as dirname14, join as join27, resolve as resolve13 } from "node:path";
+import { clampThinkingLevel } from "@earendil-works/pi-ai/compat";
 function hasSearchEvidence(toolName, details, isError) {
   if (isError || details === null || typeof details !== "object")
     return false;
@@ -17004,9 +16822,6 @@ function hasSearchEvidence(toolName, details, isError) {
   }
   return Array.isArray(outcome.sources) && outcome.sources.some((source) => typeof source === "string" && source.trim().length > 0) || Array.isArray(outcome.results) && outcome.results.some((result) => result !== null && typeof result === "object" && typeof result.source === "string" && result.source.trim().length > 0);
 }
-function keepLlmMessages(messages) {
-  return messages.filter((message) => message.role === "system" || message.role === "user" || message.role === "assistant" || message.role === "toolResult");
-}
 function positiveLimit(value, fallback, path) {
   if (value === undefined)
     return fallback;
@@ -17047,6 +16862,7 @@ class AutoRAGAgent {
   sessions = new Map;
   activeRun = false;
   resultCapture;
+  interactiveFastAnswerCallback;
   modelNativeSearchAuth;
   retrievalTrace = [];
   preliminaryCallback;
@@ -17095,6 +16911,10 @@ class AutoRAGAgent {
   droppedCallerToolNames;
   searchTimeoutMs;
   maxSearchToolCalls;
+  piAgentDir;
+  piSessionDir;
+  persistPiSessions;
+  boundPiRuntime;
   remoteSession;
   activeRetrievalOptions;
   searchToolCallCount = 0;
@@ -17116,6 +16936,9 @@ class AutoRAGAgent {
     this.finalThinkingLevel = thinking === false ? undefined : thinking?.final ?? "high";
     this.apiKey = options.apiKey;
     this.providerApiKeys = options.providerApiKeys;
+    this.piAgentDir = options.piAgentDir;
+    this.piSessionDir = options.piSessionDir;
+    this.persistPiSessions = options.persistPiSessions ?? true;
     const manifests = manifestDir ? loadManifests(manifestDir) : [];
     this.datasourceSkills = options.datasourceSkills ?? [];
     this.datasourceVirtualScopePrefixes = this.datasourceSkills.map((skill) => normalizeVirtualPath2(`/${skill.describe().name}`));
@@ -17176,10 +16999,10 @@ class AutoRAGAgent {
       if (fsearchClient.isSupported())
         this.fsearchClient = fsearchClient;
     }
-    const memPath = memoryPath ?? join26(resolveAutoRAGHome(), "memory.json");
+    const memPath = memoryPath ?? join27(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
-    this.runLogger = new AutoRAGRunLogger(join26(dirname15(memPath), "logs", "runs.jsonl"));
+    this.runLogger = new AutoRAGRunLogger(join27(dirname14(memPath), "logs", "runs.jsonl"));
     const checkMemoryTool = createCheckMemoryTool(this.memory);
     const singleDatasourceTools = createSingleDatasourceSearchTools(this, this.singleDatasourceToolSpecs());
     this.searchToolNames = new Set([...SEARCH_TOOLS, ...singleDatasourceTools.map((tool) => tool.name)]);
@@ -17188,16 +17011,13 @@ class AutoRAGAgent {
     const loadDatasourceSkillTool = createLoadDatasourceSkillTool(this);
     const emitResultsTool = createEmitResultsTool((details) => this.resultCapture?.(details));
     const scanDuplicateDocumentsTool = this.dupeyOptions === false ? undefined : createScanDuplicateDocumentsTool(this);
-    const bashTool = createBashTool({
-      cwd: this.workspaceProjectRoot
-    });
     const peerTargetTool = this.remoteSession ? undefined : createRecommendPeerTargetsTool(this.workspaceProjectRoot);
     const peerQuery = options.peerQuery;
     const queryPeerTool = this.remoteSession || peerQuery === undefined || peerQuery === false ? undefined : createQueryPeerAgentTool({
       workspacePath: this.workspaceProjectRoot,
       onResponse: peerQuery?.onResponse,
       openTransport: peerQuery?.openTransport ?? (() => openPeerQueryTransport({
-        dbPrefix: peerQuery?.simplexDbPrefix ?? join26(this.workspaceProjectRoot, ".autorag", "p2p", "simplex"),
+        dbPrefix: peerQuery?.simplexDbPrefix ?? join27(this.workspaceProjectRoot, ".autorag", "p2p", "simplex"),
         displayName: `autorag-${basename11(this.workspaceProjectRoot) || "node"}`
       })),
       autoStart: true,
@@ -17211,7 +17031,7 @@ class AutoRAGAgent {
     const webSearchTool = webToolsEnabled ? createWebSearchTool({ ...webSearchOption ?? {}, modelAuth: () => this.modelNativeSearchAuth }) : undefined;
     const webFetchTool = webToolsEnabled && webSearchOption?.fetch !== false ? createWebFetchTool(webSearchOption?.fetch ?? {}) : undefined;
     const reservedNames = new Set([
-      BASH_TOOL_NAME,
+      ...PI_BUILTIN_TOOL_NAMES,
       "check_memory",
       ...singleDatasourceTools.map((tool) => tool.name),
       LOAD_DATASOURCE_SKILL_TOOL_NAME,
@@ -17238,7 +17058,6 @@ class AutoRAGAgent {
     });
     this.droppedCallerToolNames = [...new Set(droppedCallerToolNames)];
     const orderedTools = [
-      ...bashTool !== undefined ? [bashTool] : [],
       ...callerTools,
       checkMemoryTool,
       searchMinSyncTool,
@@ -17263,7 +17082,7 @@ class AutoRAGAgent {
       return true;
     });
     this.tools = tools;
-    const toolNames = tools.map((tool) => tool.name);
+    const toolNames = [...PI_BUILTIN_TOOL_NAMES, ...tools.map((tool) => tool.name)];
     this.baseSystemPromptConfig = {
       toolNames,
       modelId: options.model?.id,
@@ -17274,28 +17093,14 @@ class AutoRAGAgent {
       retrievedContentGuard: false
     };
     const systemPrompt = buildSystemPrompt(this.currentSystemPromptConfig());
-    this.innerAgent = new Agent({
-      initialState: {
+    this.innerAgent = {
+      state: {
         systemPrompt,
-        model: options.model,
-        tools
+        tools: [...PI_BUILTIN_TOOL_NAMES.map((name) => ({ name })), ...tools],
+        messages: []
       },
-      streamFn: streamSimple,
-      convertToLlm: keepLlmMessages,
-      transformContext: async (messages) => this.withMemoryContext(messages),
-      afterToolCall: async (context) => {
-        const toolName = context.toolCall.name;
-        if (!this.lastQuery || !this.searchToolNames.has(toolName))
-          return;
-        if (!hasSearchEvidence(toolName, context.result.details, context.isError))
-          return;
-        const details = context.result.details;
-        const method = details?.method ?? toolName;
-        this.memory.recordWeakSignal(this.lastQuery, method, "followup");
-        this.memory.save();
-        return;
-      }
-    });
+      transformContext: (messages) => this.withMemoryContext(messages)
+    };
     if (options.autoRefresh) {
       this.startAutoRefresh(options.autoRefresh.intervalMs, { immediate: options.autoRefresh.immediate });
     }
@@ -17336,7 +17141,16 @@ ${summary}
       ...messages
     ];
   }
-  resolveSessionModel() {
+  async resolveSessionModel() {
+    const boundModel = this.boundPiRuntime?.session.model;
+    if (boundModel !== undefined) {
+      const auth = await this.boundPiRuntime?.session.modelRuntime.getAuth(boundModel);
+      const apiKey = auth?.auth.apiKey;
+      return {
+        model: boundModel,
+        ...apiKey !== undefined ? { apiKey, providerApiKeys: { [boundModel.provider]: apiKey } } : {}
+      };
+    }
     if (this.configuredModel !== undefined) {
       return {
         model: this.configuredModel,
@@ -17351,19 +17165,40 @@ ${summary}
       providerApiKeys: { [local.provider]: local.apiKey }
     };
   }
-  createSearchSession(resolved, systemPrompt) {
-    const agent = new Agent({
-      initialState: { systemPrompt, model: resolved.model, tools: [...this.tools] },
-      streamFn: streamSimple,
-      getApiKey: (provider) => resolved.providerApiKeys?.[provider] ?? (provider === resolved.model.provider ? resolved.apiKey : undefined),
-      convertToLlm: keepLlmMessages,
-      transformContext: async (messages) => this.withMemoryContext(messages)
+  async createSearchSession(resolved, systemPrompt, extraTools = []) {
+    if (this.boundPiRuntime !== undefined) {
+      const session = this.boundPiRuntime.session;
+      return {
+        agent: session.agent,
+        piSession: session,
+        prompt: async (prompt) => session.prompt(prompt, { source: "extension" }),
+        abort: async () => session.abort(),
+        dispose: () => {}
+      };
+    }
+    const piSession = await createAutoRAGPiSession({
+      cwd: this.workspaceProjectRoot,
+      agentDir: this.piAgentDir,
+      sessionDir: this.piSessionDir,
+      persistSession: this.persistPiSessions,
+      model: resolved.model,
+      apiKey: resolved.apiKey,
+      providerApiKeys: resolved.providerApiKeys,
+      getSystemPrompt: () => systemPrompt,
+      customTools: [
+        ...this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
+        ...extraTools
+      ],
+      remoteSession: this.remoteSession,
+      contextTransform: (messages) => this.withMemoryContext(messages)
     });
+    const agent = piSession.session.agent;
     return {
       agent,
-      prompt: async (prompt) => agent.prompt(prompt),
-      abort: async () => agent.abort(),
-      dispose: () => {}
+      piSession: piSession.session,
+      prompt: async (prompt) => piSession.session.prompt(prompt, { source: "extension" }),
+      abort: async () => piSession.session.abort(),
+      dispose: () => piSession.session.dispose()
     };
   }
   configureSearchSession(session) {
@@ -17414,6 +17249,55 @@ ${summary}
       this.listeners.delete(listener);
     };
   }
+  async createPiInteractiveRuntime() {
+    const resolved = this.configuredModel === undefined ? undefined : await this.resolveSessionModel();
+    const runtime = await createAutoRAGPiInteractiveRuntime({
+      cwd: this.workspaceProjectRoot,
+      agentDir: this.piAgentDir,
+      sessionDir: this.piSessionDir,
+      persistSession: this.persistPiSessions,
+      ...resolved === undefined ? {} : {
+        model: resolved.model,
+        ...resolved.apiKey !== undefined ? { apiKey: resolved.apiKey } : {},
+        ...resolved.providerApiKeys !== undefined ? { providerApiKeys: resolved.providerApiKeys } : {}
+      },
+      getSystemPrompt: () => buildSystemPrompt(this.currentSystemPromptConfig({
+        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)),
+        ...this.fastThinkingLevel === undefined ? [] : [createEmitFastAnswerTool((details) => this.interactiveFastAnswerCallback?.(details))]
+      ],
+      onQuery: (query, pi) => this.runInteractivePiQuery(query, pi),
+      inactiveToolNames: this.fastThinkingLevel === undefined ? [] : [EMIT_FAST_ANSWER_TOOL_NAME]
+    });
+    this.boundPiRuntime = runtime.runtime;
+    if (this.fastThinkingLevel !== undefined) {
+      runtime.runtime.session.setActiveToolsByName(runtime.runtime.session.getActiveToolNames().filter((name) => name !== EMIT_FAST_ANSWER_TOOL_NAME));
+    }
+    const dispose = runtime.dispose;
+    return {
+      ...runtime,
+      dispose: async () => {
+        if (this.boundPiRuntime === runtime.runtime)
+          this.boundPiRuntime = undefined;
+        await dispose();
+      }
+    };
+  }
+  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
+      });
+    }
+  }
   abort() {
     this.activeSession?.abort();
   }
@@ -17496,14 +17380,21 @@ ${summary}
     this.scheduleMinSyncPrepare();
     let captured;
     let fastCaptured;
+    const emitPreliminary = (details) => {
+      if (fastCaptured !== undefined)
+        return;
+      fastCaptured = details;
+      this.preliminaryCallback?.(createPreliminarySearchDocumentsResponse(sessionId, trimmedQuery, details, this.collectComponentDiagnostics()));
+    };
     let session;
+    this.interactiveFastAnswerCallback = emitPreliminary;
     let unsubscribers = [];
     this.resultCapture = (details) => {
       captured = details;
     };
     let searchStarted = false;
     try {
-      const resolved = this.resolveSessionModel();
+      const resolved = await this.resolveSessionModel();
       this.modelNativeSearchAuth = modelNativeAuthFromAgentModel({
         provider: resolved.model.provider,
         ...resolved.apiKey !== undefined ? { apiKey: resolved.apiKey } : {},
@@ -17518,7 +17409,7 @@ ${summary}
         model: resolved.model.id
       });
       searchStarted = true;
-      session = this.createSearchSession(resolved, buildSystemPrompt(this.currentSystemPromptConfig({ modelId: resolved.model.id })));
+      session = await this.createSearchSession(resolved, buildSystemPrompt(this.currentSystemPromptConfig({ modelId: resolved.model.id })), this.fastThinkingLevel === undefined ? [] : [createEmitFastAnswerTool(emitPreliminary)]);
       this.activeSession = session;
       unsubscribers = this.configureSearchSession(session);
       let timeout;
@@ -17536,28 +17427,35 @@ ${initialRetrievalContext}`);
               }
               return;
             }
-            const emitPreliminary = (details) => {
-              if (fastCaptured !== undefined)
-                return;
-              fastCaptured = details;
-              this.preliminaryCallback?.(createPreliminarySearchDocumentsResponse(sessionId, trimmedQuery, details, this.collectComponentDiagnostics()));
-            };
-            const fastTool = createEmitFastAnswerTool(emitPreliminary);
             const baseline = await retrievalPromise;
-            session.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.fastThinkingLevel);
-            session.agent.state.tools = [...this.tools, fastTool];
+            const sessionAgent = session.piSession;
+            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 {
+              session.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.fastThinkingLevel);
+              session.agent.state.tools = [...this.tools, { name: EMIT_FAST_ANSWER_TOOL_NAME }];
+            }
             await session.prompt(this.buildFastAnswerPrompt(trimmedQuery, options, baseline));
             let preliminary = fastCaptured;
             if (preliminary === undefined) {
-              const text = lastAssistantText(session.agent.state.messages);
+              const text = lastAssistantText(session.piSession?.messages ?? session.agent.state.messages);
               if (text !== undefined)
                 preliminary = { answer: text, results: [], sources: [] };
             }
             if (preliminary !== undefined)
               emitPreliminary(preliminary);
             if (captured === undefined && this.finalThinkingLevel !== undefined) {
-              session.agent.state.thinkingLevel = clampThinkingLevel(resolved.model, this.finalThinkingLevel);
-              session.agent.state.tools = [...this.tools];
+              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];
+              }
               const fastAnswerDelivered = preliminary !== undefined && this.preliminaryCallback !== undefined;
               await session.prompt(this.buildRefinementPrompt(trimmedQuery, options, preliminary, fastAnswerDelivered));
             }
@@ -17686,6 +17584,8 @@ ${initialRetrievalContext}`);
       this.resultCapture = undefined;
       this.activeRetrievalOptions = undefined;
       this.preliminaryCallback = undefined;
+      if (this.interactiveFastAnswerCallback === emitPreliminary)
+        this.interactiveFastAnswerCallback = undefined;
       this.activeRun = false;
     }
   }
@@ -18082,7 +17982,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         lastError: undefined
       };
       if (needsParsed) {
-        mkdirSync16(dirname15(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
+        mkdirSync16(dirname14(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
         writeFileSync15(refreshReadinessPath(this.workspaceProjectRoot), `{"version":1,"completed":true,"parsed":true}
 `);
       }
@@ -18294,7 +18194,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
       written: 0,
       deleted: 0,
       skipped: 0,
-      indexPath: join26(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
+      indexPath: join27(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
       diagnostics
     };
   }
@@ -18840,7 +18740,7 @@ function toMinSyncReasonDiagnostic(reason) {
 function pinExcludedPath(path) {
   const resolvedPath = resolve13(path);
   try {
-    return join26(realpathSync5(dirname15(resolvedPath)), basename11(resolvedPath));
+    return join27(realpathSync5(dirname14(resolvedPath)), basename11(resolvedPath));
   } catch {
     return resolvedPath;
   }
@@ -18901,7 +18801,6 @@ var init_agent = __esm(() => {
   init_rerank();
   init_scope();
   init_model_auth();
-  init_bash_tool();
   init_datasource_skill();
   init_dupey_tool();
   init_emit_results_tool();
@@ -18911,6 +18810,7 @@ var init_agent = __esm(() => {
   init_jikji_find_tool();
   init_local_model();
   init_peer_target_tool();
+  init_pi_session();
   init_query_peer_tool();
   init_refresh_progress();
   init_search_all_tool();
@@ -19103,7 +19003,7 @@ ${this.description}`
 }
 
 // src/datasource/skills/clawgallery/client.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { existsSync as existsSync21 } from "node:fs";
 
 class ClawGalleryClient {
@@ -19208,7 +19108,7 @@ class ClawGalleryClient {
 function spawnCli(binary, args, env, options, signal) {
   return new Promise((resolve) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn10(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn9(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let settled = false;
@@ -19217,7 +19117,7 @@ function spawnCli(binary, args, env, options, signal) {
     const timeout = setTimeout(() => {
       reason = "timeout";
       terminate2(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS7);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS6);
     const abort = () => {
       reason = "aborted";
       terminate2(child);
@@ -19332,7 +19232,7 @@ function boundDiagnosticText(value) {
     return "";
   return value.trim().slice(0, 4000);
 }
-var DEFAULT_BINARY2 = "clawgallery", DEFAULT_TIMEOUT_MS7 = 60000, DEFAULT_MAX_BUFFER_BYTES2, SAFE_ENV;
+var DEFAULT_BINARY2 = "clawgallery", DEFAULT_TIMEOUT_MS6 = 60000, DEFAULT_MAX_BUFFER_BYTES2, SAFE_ENV;
 var init_client5 = __esm(() => {
   init_portable_spawn();
   DEFAULT_MAX_BUFFER_BYTES2 = 4 * 1024 * 1024;
@@ -19660,7 +19560,7 @@ function statusToReason(status) {
 }
 async function requestText(url, options) {
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS7;
   let response;
   try {
     response = await fetchImpl(url, {
@@ -19724,13 +19624,13 @@ function resolveToken(token, tokenEnv) {
   }
   return;
 }
-var DEFAULT_TIMEOUT_MS8 = 15000;
+var DEFAULT_TIMEOUT_MS7 = 15000;
 
 // src/datasource/skills/cloud-drive/rclone-connector.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 import { mkdirSync as mkdirSync17, readFileSync as readFileSync17, renameSync as renameSync10, rmSync as rmSync7, writeFileSync as writeFileSync16 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname16, join as join27, normalize as normalize3 } from "node:path";
+import { dirname as dirname15, join as join28, normalize as normalize3 } from "node:path";
 
 class RcloneConnector {
   options;
@@ -19746,7 +19646,7 @@ class RcloneConnector {
     if (remote === undefined || remote.length === 0) {
       return { ok: false, reason: "not-configured", message: "rclone remote not configured" };
     }
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS9;
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
     const exportFormats = this.options.exportFormats ?? DEFAULT_EXPORT_FORMATS;
     let listResult;
     try {
@@ -19817,7 +19717,7 @@ class RcloneConnector {
         return;
       const destination = mirrorFilePath(paths.mirrorRoot, entry.path);
       const temp = `${destination}.autorag-tmp`;
-      mkdirSync17(dirname16(temp), { recursive: true });
+      mkdirSync17(dirname15(temp), { recursive: true });
       let copied;
       try {
         copied = await this.runner(copyArgs(remote, entry.path, temp, exportFormats, this.options.concurrency, this.options.bandwidthLimit), timeoutMs);
@@ -19922,12 +19822,12 @@ function sameEntry(previous, current) {
   return previous?.path === current.path && previous.size === current.size && previous.modTime === current.modTime && previous.remoteId === current.remoteId && JSON.stringify(previous.hashes) === JSON.stringify(current.hashes);
 }
 function mirrorPaths(workspaceRoot, skillName, instanceId) {
-  const base = join27(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
-  return { mirrorRoot: join27(base, "mirror"), manifestPath: join27(base, "manifest.json") };
+  const base = join28(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
+  return { mirrorRoot: join28(base, "mirror"), manifestPath: join28(base, "manifest.json") };
 }
 function mirrorFilePath(root, path) {
   const safe = normalize3(path).replace(/^(\.\.(?:[/\\]|$))+|^[/\\]+/gu, "");
-  return join27(root, safe);
+  return join28(root, safe);
 }
 function remoteTarget(remote, path) {
   return remote.endsWith(":") || remote.endsWith("/") ? `${remote}${path}` : `${remote}/${path}`;
@@ -19953,7 +19853,7 @@ function loadManifest2(path) {
   }
 }
 function saveManifest(path, manifest) {
-  mkdirSync17(dirname16(path), { recursive: true });
+  mkdirSync17(dirname15(path), { recursive: true });
   const temp = `${path}.autorag-tmp`;
   writeFileSync16(temp, `${JSON.stringify(manifest)}
 `, "utf8");
@@ -20031,7 +19931,7 @@ function shortFailure(result) {
 function runBinary(binary, args, timeoutMs, env, cwd) {
   return new Promise((resolvePromise) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn11(portable.command, [...portable.args], {
+    const child = spawn10(portable.command, [...portable.args], {
       ...env === undefined ? {} : { env: { ...process.env, ...env } },
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -20055,7 +19955,7 @@ function runBinary(binary, args, timeoutMs, env, cwd) {
     });
   });
 }
-var DEFAULT_BINARY3 = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS9 = 60000, MAX_CONTENT_CHARS = 1e5;
+var DEFAULT_BINARY3 = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS8 = 60000, MAX_CONTENT_CHARS = 1e5;
 var init_rclone_connector = __esm(() => {
   init_defaults();
   init_portable_spawn();
@@ -20106,9 +20006,9 @@ var init_connector = () => {};
 
 // src/datasource/chunk-store.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync18, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname17, join as join28 } from "node:path";
+import { dirname as dirname16, join as join29 } from "node:path";
 function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
-  return join28(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
+  return join29(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
 }
 
 class DatasourceChunkStore {
@@ -20221,7 +20121,7 @@ class DatasourceChunkStore {
     if (this.storePath === undefined)
       return;
     try {
-      mkdirSync18(dirname17(this.storePath), { recursive: true });
+      mkdirSync18(dirname16(this.storePath), { recursive: true });
       const payload = {
         version: STORE_VERSION,
         skill: this.skillName,
@@ -20644,13 +20544,13 @@ var init_cloud_drive = __esm(() => {
 });
 
 // src/process/terminate-tree.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 function terminateProcessTree(child, signal = "SIGKILL") {
   const pid = child.pid;
   if (pid === undefined)
     return false;
   if (process.platform === "win32") {
-    const killer = spawn12("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+    const killer = spawn11("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
     killer.on("error", () => killDirectChild(child, signal));
     killer.on("close", (code) => {
       if (code !== 0)
@@ -20693,9 +20593,9 @@ var init_types4 = __esm(() => {
 });
 
 // src/datasource/skills/discrawl/client.ts
-import { spawn as spawn13 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 import { mkdirSync as mkdirSync19, readFileSync as readFileSync19, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname18 } from "node:path";
+import { dirname as dirname17 } from "node:path";
 
 class DiscrawlClient {
   options;
@@ -20719,7 +20619,7 @@ class DiscrawlClient {
       return { configured: false, rebuildRequired: false };
     const previous = managed ? parseManagedEmbedding(existing) : undefined;
     const config = managedDiscrawlConfig({ ...runtime, baseUrl: nativeGatewayBaseUrl(runtime.baseUrl) });
-    mkdirSync19(dirname18(path), { recursive: true });
+    mkdirSync19(dirname17(path), { recursive: true });
     if (existing !== config)
       writeFileSync18(path, config, "utf8");
     return {
@@ -20833,7 +20733,7 @@ function spawnDiscrawl(request) {
   return new Promise((resolveResult) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(options.binaryPath ?? DEFAULT_DISCRAWL_BINARY, args);
-    const child = spawn13(portable.command, [...portable.args], {
+    const child = spawn12(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -21742,12 +21642,12 @@ var init_github = __esm(() => {
 });
 
 // src/datasource/skills/github-gist/connector.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync23, mkdirSync as mkdirSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync19 } from "node:fs";
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname18 } from "node:path";
 async function defaultGhTokenRunner() {
   return new Promise((resolve) => {
-    execFile3("gh", ["auth", "token"], { timeout: GH_TOKEN_TIMEOUT_MS }, (error, stdout) => {
+    execFile2("gh", ["auth", "token"], { timeout: GH_TOKEN_TIMEOUT_MS }, (error, stdout) => {
       if (error) {
         resolve(undefined);
         return;
@@ -21880,7 +21780,7 @@ class GitHubGistConnector {
     if (statePath === undefined)
       return;
     try {
-      mkdirSync20(dirname19(statePath), { recursive: true });
+      mkdirSync20(dirname18(statePath), { recursive: true });
       writeFileSync19(statePath, `${JSON.stringify(state)}
 `, "utf8");
     } catch {}
@@ -21927,7 +21827,7 @@ var init_connector3 = () => {};
 // src/datasource/skills/github-gist/semantic.ts
 import { createHash as createHash10 } from "node:crypto";
 import { existsSync as existsSync24, mkdirSync as mkdirSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync20 } from "node:fs";
-import { dirname as dirname20 } from "node:path";
+import { dirname as dirname19 } from "node:path";
 function contentHash(chunk) {
   return createHash10("sha256").update(`${chunk.title ?? ""}
 ${chunk.content}`).digest("hex");
@@ -22035,7 +21935,7 @@ ${chunk.content}`));
     if (this.identity === undefined)
       return;
     try {
-      mkdirSync21(dirname20(this.statePath), { recursive: true });
+      mkdirSync21(dirname19(this.statePath), { recursive: true });
       const payload = {
         version: VECTORS_VERSION,
         identity: this.identity,
@@ -22175,9 +22075,9 @@ var init_semantic = __esm(() => {
 });
 
 // src/datasource/skills/github-gist/skill.ts
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function gistDatasourceDir(workspaceRoot, skillName, instanceId) {
-  return join29(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
+  return join30(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
 }
 var GITHUB_GIST_SKILL_DEFINITION, DEFAULT_INSTANCE_ID3 = "default", GitHubGistSkill;
 var init_skill5 = __esm(() => {
@@ -22205,7 +22105,7 @@ var init_skill5 = __esm(() => {
     constructor(options = {}) {
       const { connector, connectorOptions, semantic, ...rest } = options;
       const instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID3;
-      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join29(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
+      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join30(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
       super(GITHUB_GIST_SKILL_DEFINITION, {
         ...rest,
         connector: connector ?? new GitHubGistConnector({
@@ -22215,7 +22115,7 @@ var init_skill5 = __esm(() => {
       });
       if (semantic?.enabled !== false) {
         this.semanticIndex = new GistSemanticIndex({
-          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join29(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
+          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join30(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
         });
         this.semanticEmbedder = semantic?.embedder ?? createGatewayGistEmbedder(semantic?.embedderOptions ?? {});
         this.semanticMethod = new GitHubGistSemanticMethod({
@@ -22271,7 +22171,7 @@ function connectorSyncTimeoutHint() {
 var DEFAULT_CONNECTOR_SYNC_TIMEOUT_MS = 1800000;
 
 // src/datasource/crawler-client.ts
-import { spawn as spawn14 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 
 class CrawlerCliClient {
   profile;
@@ -22308,7 +22208,7 @@ class CrawlerCliClient {
 function spawnCrawler(command, args, env, signal, options, timeoutMs, cwd) {
   return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
-    const child = spawn14(portable.command, [...portable.args], {
+    const child = spawn13(portable.command, [...portable.args], {
       env,
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -22936,9 +22836,9 @@ var init_types5 = __esm(() => {
 });
 
 // src/datasource/skills/lazykatok/client.ts
-import { spawn as spawn15 } from "node:child_process";
+import { spawn as spawn14 } from "node:child_process";
 import { existsSync as existsSync25 } from "node:fs";
-import { delimiter as delimiter4, join as join30 } from "node:path";
+import { delimiter as delimiter4, join as join31 } from "node:path";
 
 class LazykatokClient {
   options;
@@ -23036,7 +22936,7 @@ function spawnLazykatok(request) {
   return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(commandFor2(options, env), args);
-    const child = spawn15(portable.command, [...portable.args], {
+    const child = spawn14(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -23126,7 +23026,7 @@ function lookupInPath2(executable, env) {
   for (const dir of pathEnv.split(delimiter4)) {
     if (dir.length === 0)
       continue;
-    const candidate = join30(dir, executable);
+    const candidate = join31(dir, executable);
     if (existsSync25(candidate))
       return candidate;
   }
@@ -23616,7 +23516,7 @@ var init_lazykatok = __esm(() => {
 
 // src/datasource/skills/mail-export/connector.ts
 import { readdir as readdir3, readFile as readFile5, stat as stat6 } from "node:fs/promises";
-import { basename as basename12, dirname as dirname21, extname as extname7, join as join31 } from "node:path";
+import { basename as basename12, dirname as dirname20, extname as extname7, join as join32 } from "node:path";
 import { simpleParser as simpleParser2 } from "mailparser";
 
 class MailExportConnector {
@@ -23642,7 +23542,7 @@ class MailExportConnector {
               continue;
             const extension = extname7(entry.name).toLowerCase();
             if (extension === ".eml" || extension === ".mbox") {
-              files.push(join31(entry.parentPath, entry.name));
+              files.push(join32(entry.parentPath, entry.name));
             }
           }
         } else if (info.isFile()) {
@@ -23677,7 +23577,7 @@ class MailExportConnector {
         continue;
       }
       const stem = basename12(file, extname7(file));
-      const mailboxDir = basename12(dirname21(file));
+      const mailboxDir = basename12(dirname20(file));
       const hierarchy = ["mailboxes", mailboxDir, stem];
       const extension = extname7(file).toLowerCase();
       const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
@@ -23801,7 +23701,7 @@ function ensurePrivateMailcrawlDataDir(path) {
 var init_config = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
-import { spawn as spawn16 } from "node:child_process";
+import { spawn as spawn15 } from "node:child_process";
 
 class MailcrawlClient {
   options;
@@ -23921,7 +23821,7 @@ class MailcrawlClient {
 function spawnMailcrawl(binary, args, env, options, signal, timeoutMs) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn16(portable.command, portable.args, {
+    const child = spawn15(portable.command, portable.args, {
       env,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"]
@@ -24752,15 +24652,15 @@ var init_notion = __esm(() => {
 });
 
 // src/datasource/skills/obsidian/paths.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function obsidianDatasourceRoot(workspaceRoot, instanceId) {
-  return join32(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
+  return join33(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
 }
 function obsidianQmdConfigDir(workspaceRoot, instanceId) {
-  return join32(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
+  return join33(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
 }
 function obsidianQmdCacheDir(workspaceRoot, instanceId) {
-  return join32(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
+  return join33(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
 }
 function stripEdgeDashes(value) {
   let start = 0;
@@ -24782,7 +24682,7 @@ var init_paths5 = () => {};
 var DEFAULT_QMD_BINARY = "qmd", DEFAULT_QMD_TIMEOUT_MS = 60000, DEFAULT_QMD_MAX_BUFFER_BYTES = 1048576;
 
 // src/datasource/skills/obsidian/client.ts
-import { spawn as spawn17 } from "node:child_process";
+import { spawn as spawn16 } from "node:child_process";
 import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync21 } from "node:fs";
 import { isAbsolute as isAbsolute6, resolve as resolve14 } from "node:path";
 
@@ -24907,7 +24807,7 @@ function isAllowedEnvKey2(key) {
 function spawnQmd(request) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(request.binaryPath ?? DEFAULT_QMD_BINARY, request.args);
-    const child = spawn17(portable.command, [...portable.args], {
+    const child = spawn16(portable.command, [...portable.args], {
       env: request.env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -25780,7 +25680,7 @@ var init_slack = __esm(() => {
 });
 
 // src/datasource/skills/spotlight/connector.ts
-import { spawn as spawn18 } from "node:child_process";
+import { spawn as spawn17 } from "node:child_process";
 import { createHash as createHash11 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat7 } from "node:fs/promises";
 import { basename as basename13, extname as extname8 } from "node:path";
@@ -25804,7 +25704,7 @@ class SpotlightConnector {
     if (queries.length === 0) {
       return { ok: false, reason: "not-configured", message: "no spotlight queries configured" };
     }
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS10;
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS9;
     const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
     if (status.ok && /indexing disabled/iu.test(status.stdout)) {
       return {
@@ -25899,8 +25799,8 @@ class SpotlightConnector {
     return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
   }
 }
-var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS5 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS10 = 15000, MAX_CONTENT_CHARS3 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve) => {
-  const child = spawn18(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS5 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS9 = 15000, MAX_CONTENT_CHARS3 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve) => {
+  const child = spawn17(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
   let settled = false;
@@ -26461,8 +26361,9 @@ var init_factory = __esm(() => {
 // src/cli/config.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync26, mkdirSync as mkdirSync24, readFileSync as readFileSync22, renameSync as renameSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync22 } from "node:fs";
-import { basename as basename14, dirname as dirname22, isAbsolute as isAbsolute7, join as join33, resolve as resolve15 } from "node:path";
-import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
+import { basename as basename14, dirname as dirname21, isAbsolute as isAbsolute7, join as join34, resolve as resolve15 } from "node:path";
+import { findEnvKeys, getEnvApiKey } from "@earendil-works/pi-ai/compat";
+import { getAgentDir as getAgentDir2, ModelRuntime as ModelRuntime2, SettingsManager as SettingsManager2 } from "@earendil-works/pi-coding-agent";
 function resolveConfigPath(input) {
   const flags = input.flags;
   const env = input.env ?? process.env;
@@ -26476,9 +26377,9 @@ function resolveConfigPath(input) {
     return { configPath: envConfig, explicit: true };
   }
   return {
-    configPath: join33(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
+    configPath: join34(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
     explicit: false,
-    legacyPath: join33(cwd, LEGACY_CONFIG_FILENAME)
+    legacyPath: join34(cwd, LEGACY_CONFIG_FILENAME)
   };
 }
 function readConfigFile(configPath, explicit) {
@@ -26534,7 +26435,7 @@ function acquireConfigWriteLock(configPath) {
   });
 }
 function replaceFileAtomically(path, contents, assertCommitAllowed) {
-  const temporaryPath = join33(dirname22(path), `.${basename14(path)}.${process.pid}.${randomUUID9()}.tmp`);
+  const temporaryPath = join34(dirname21(path), `.${basename14(path)}.${process.pid}.${randomUUID9()}.tmp`);
   try {
     writeFileSync22(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     assertCommitAllowed?.();
@@ -26548,11 +26449,11 @@ function migrateLegacyConfig(configPath, legacyPath) {
     return;
   const legacy = readConfigFile(legacyPath, true);
   const legacyBytes = readFileSync22(legacyPath);
-  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname22(legacyPath));
+  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname21(legacyPath));
   const migratedPathsUnchanged = legacy?.workspacePath === migrated.workspacePath && legacy?.memoryPath === migrated.memoryPath && JSON.stringify(legacy?.searchPaths) === JSON.stringify(migrated.searchPaths);
   const migratedBytes = migratedPathsUnchanged ? legacyBytes : `${JSON.stringify(migrated, null, 2)}
 `;
-  mkdirSync24(dirname22(configPath), { recursive: true });
+  mkdirSync24(dirname21(configPath), { recursive: true });
   const lock = acquireConfigWriteLock(configPath);
   try {
     const winner = readConfigFile(configPath, false);
@@ -26582,7 +26483,7 @@ function resolveConfigFileReadOnly(configPath, explicit, legacyPath) {
   const legacy = readConfigFile(legacyPath, false);
   if (legacy === undefined)
     return {};
-  return normalizeLegacyConfigPaths(legacy, dirname22(legacyPath));
+  return normalizeLegacyConfigPaths(legacy, dirname21(legacyPath));
 }
 function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
@@ -27017,10 +26918,10 @@ function resolveConfig(input) {
   const file = readOnly ? resolveConfigFileReadOnly(configPath, explicit, legacyPath) : !explicit && legacyPath ? migrateLegacyConfig(configPath, legacyPath) ?? readConfigFile(configPath, explicit) ?? {} : readConfigFile(configPath, explicit) ?? {};
   const defaultSearchPaths = ["."];
   const defaultWorkspacePath = cwd;
-  const defaultMemoryPath = join33(resolveAutoRAGHome(env), "memory.json");
+  const defaultMemoryPath = join34(resolveAutoRAGHome(env), "memory.json");
   const flagSearchPaths = parseCsv(flagString(flags, "search-paths"));
   const envSearchPaths = parseCsv(envString(env, "AUTORAG_SEARCH_PATHS"));
-  const configOrigin = dirname22(resolve15(configPath));
+  const configOrigin = dirname21(resolve15(configPath));
   const fileWorkspacePath = typeof file.workspacePath === "string" ? resolvePersistedPath(file.workspacePath, configOrigin) : undefined;
   const fileSearchPaths = file.searchPaths ? resolveSearchPaths(file.searchPaths, fileWorkspacePath ?? configOrigin) : undefined;
   if (file.excludePaths !== undefined && (!Array.isArray(file.excludePaths) || file.excludePaths.some((path) => typeof path !== "string" || path.length === 0))) {
@@ -27185,6 +27086,9 @@ function normalizeRerankConfig(raw, path) {
     }
     out.provider = record.provider.trim();
   }
+  if (!SUPPORTED_RERANK_PROVIDERS.includes(out.provider ?? "")) {
+    throw new ConfigError(`${path}.provider must be one of: ${SUPPORTED_RERANK_PROVIDERS.join(", ")}`);
+  }
   if (record.model !== undefined) {
     if (typeof record.model !== "string" || record.model.trim() === "") {
       throw new ConfigError(`${path}.model must be a non-empty string`);
@@ -27316,12 +27220,7 @@ function buildModelFromConfiguredEndpoint(reference) {
     maxTokens: reference.maxTokens ?? 16384
   };
 }
-function resolveCatalogModel(reference) {
-  if (!getProviders().includes(reference.provider))
-    return;
-  const catalog = getModel(reference.provider, reference.id);
-  if (catalog === undefined)
-    return;
+function mergeCatalogModel(catalog, reference) {
   return {
     ...catalog,
     ...reference.name !== undefined ? { name: reference.name } : {},
@@ -27333,109 +27232,120 @@ function resolveCatalogModel(reference) {
     ...reference.maxTokens !== undefined ? { maxTokens: reference.maxTokens } : {}
   };
 }
-function resolveRegisteredModel(reference) {
-  const catalog = resolveCatalogModel(reference);
+function resolveRuntimeCatalogModel(runtime, reference) {
+  const catalog = runtime.getModel(reference.provider, reference.id);
+  if (catalog === undefined)
+    return;
+  return mergeCatalogModel(catalog, reference);
+}
+function resolveRegisteredModel(runtime, reference) {
+  const catalog = resolveRuntimeCatalogModel(runtime, reference);
   if (catalog !== undefined)
     return catalog;
   if (isConfiguredEndpoint(reference))
     return buildModelFromConfiguredEndpoint(reference);
   throw new ConfigError(`Unknown configured model: ${reference.provider}/${reference.id}. ${UNKNOWN_MODEL_HINT}`);
 }
-function resolveBuiltInModel(reference) {
+function resolveBuiltInModel(runtime, reference) {
   if (reference === undefined)
     return;
-  const catalog = resolveCatalogModel(reference);
+  const catalog = resolveRuntimeCatalogModel(runtime, reference);
   if (catalog !== undefined)
     return catalog;
   if (isConfiguredEndpoint(reference))
     return buildModelFromConfiguredEndpoint(reference);
-  if (getProviders().includes(reference.provider)) {
+  if (runtime.getProvider(reference.provider) !== undefined) {
     throw new ConfigError(`Unknown configured model: ${reference.provider}/${reference.id}. ${UNKNOWN_MODEL_HINT}`);
   }
   return;
 }
-function resolveModel(config) {
+function resolveAgentDir(options) {
+  return options.agentDir ?? getAgentDir2();
+}
+function getModelRuntime(agentDir) {
+  const cached = modelRuntimeCache.get(agentDir);
+  if (cached !== undefined)
+    return cached;
+  const created = ModelRuntime2.create({
+    authPath: join34(agentDir, "auth.json"),
+    modelsPath: join34(agentDir, "models.json"),
+    allowModelNetwork: false
+  });
+  modelRuntimeCache.set(agentDir, created);
+  created.catch(() => {
+    modelRuntimeCache.delete(agentDir);
+  });
+  return created;
+}
+async function resolveModel(config, options = {}) {
   if (!config.model) {
     throw new ConfigError('No model configured. Provide --model-provider and --model-id on the command line, or set the "model" key (with provider and id) in the config file.');
   }
-  return resolveRegisteredModel(config.model);
+  const runtime = options.runtime ?? await getModelRuntime(resolveAgentDir(options));
+  return resolveRegisteredModel(runtime, config.model);
 }
-function resolveAgentModelCore(config, localOptions = {}) {
-  const modelRef = config.model;
-  const registered = resolveBuiltInModel(modelRef);
-  const needsLocal = modelRef === undefined || registered === undefined;
-  const localModelOptions = { ...localOptions, modelId: modelRef?.id };
-  const local = needsLocal ? loadLocalAutoRAGModel(localModelOptions) : undefined;
-  const model = registered ?? (modelRef === undefined || modelRef.provider === local?.provider ? local?.model : resolveRegisteredModel(modelRef));
-  const configuredEndpoint = isConfiguredEndpoint(modelRef);
-  const usesConfiguredEndpoint = configuredEndpoint;
-  const env = localOptions.env ?? process.env;
-  const fromLocal = registered === undefined && (modelRef === undefined || modelRef.provider === local?.provider);
-  const catalog = registered !== undefined && !configuredEndpoint;
-  if (local === undefined && !usesConfiguredEndpoint) {
-    return {
-      model,
-      modelRef,
-      fromLocal,
-      configuredEndpoint,
-      catalog,
-      local,
-      usesConfiguredEndpoint,
-      env
-    };
-  }
-  const providerApiKeys = {};
-  if (local !== undefined)
-    providerApiKeys[local.provider] = local.apiKey;
-  for (const ref of [modelRef]) {
-    if (!isConfiguredEndpoint(ref))
-      continue;
-    const envName = configuredApiKeyEnv(ref);
-    const value = env[envName];
-    if (typeof value === "string" && value.length > 0) {
-      providerApiKeys[ref.provider] = value;
-    }
-  }
-  const apiKey = local !== undefined && (modelRef === undefined || modelRef.provider === local.provider) ? local.apiKey : providerApiKeys[model.provider] !== undefined && usesConfiguredEndpoint ? providerApiKeys[model.provider] : undefined;
+function localFallbackOptions(options, modelId) {
   return {
-    model,
-    ...apiKey !== undefined ? { apiKey } : {},
-    ...Object.keys(providerApiKeys).length > 0 ? { providerApiKeys } : {},
-    modelRef,
-    fromLocal,
-    configuredEndpoint,
-    catalog,
-    local,
-    usesConfiguredEndpoint,
-    env
+    ...options.configPath !== undefined ? { configPath: options.configPath } : {},
+    ...options.env !== undefined ? { env: options.env } : {},
+    ...modelId !== undefined ? { modelId } : {}
   };
 }
-function resolveAgentModel(config, localOptions = {}) {
-  const core = resolveAgentModelCore(config, localOptions);
+function localRuntimeAuth(local) {
   return {
-    model: core.model,
-    ...core.apiKey !== undefined ? { apiKey: core.apiKey } : {},
-    ...core.providerApiKeys !== undefined ? { providerApiKeys: core.providerApiKeys } : {}
+    apiKey: local.apiKey,
+    providerApiKeys: { [local.provider]: local.apiKey },
+    present: true,
+    source: "local_runtime"
   };
 }
-function providerApiKeyEnvName(provider) {
-  return `${provider.replace(/[^A-Za-z0-9_]/g, "_").toUpperCase()}_API_KEY`;
-}
-function resolveRoleAuth(model, fromLocal, local, providerApiKeys, configuredEndpoint, apiKeyEnv, env) {
-  if (fromLocal && local !== undefined && model.provider === local.provider) {
-    return { present: true, source: "local_runtime" };
+async function resolvePiDefaultModel(runtime, options) {
+  let provider;
+  let id;
+  try {
+    const settings = SettingsManager2.create(options.cwd ?? process.cwd(), resolveAgentDir(options));
+    provider = settings.getDefaultProvider();
+    id = settings.getDefaultModel();
+  } catch {
+    return;
   }
-  if (configuredEndpoint) {
-    const envName = apiKeyEnv ?? providerApiKeyEnvName(model.provider);
-    if (providerApiKeys?.[model.provider] !== undefined) {
-      return { present: true, source: "env", envName };
-    }
-    const fromEnv = env[envName] ?? process.env[envName];
-    if (typeof fromEnv === "string" && fromEnv.length > 0) {
-      return { present: true, source: "env", envName };
-    }
-    return { present: false, source: "none", envName };
+  if (provider === undefined || id === undefined)
+    return;
+  const model = runtime.getModel(provider, id);
+  if (model === undefined)
+    return;
+  try {
+    if (await runtime.checkAuth(provider) === undefined)
+      return;
+  } catch {
+    return;
   }
+  return model;
+}
+function resolveConfiguredEndpointAuth(reference, model, env) {
+  const envName = configuredApiKeyEnv(reference);
+  const value = env[envName];
+  const providerApiKeys = typeof value === "string" && value.length > 0 ? { [model.provider]: value } : undefined;
+  const fromProcessEnv = process.env[envName];
+  const present = providerApiKeys !== undefined || typeof fromProcessEnv === "string" && fromProcessEnv.length > 0;
+  return {
+    ...providerApiKeys !== undefined ? { apiKey: providerApiKeys[model.provider], providerApiKeys } : {},
+    present,
+    source: present ? "env" : "none",
+    envName
+  };
+}
+async function resolveCatalogAuth(runtime, model, env) {
+  try {
+    const result = await runtime.getAuth(model);
+    if (result !== undefined) {
+      const apiKey = result.auth.apiKey;
+      if (typeof apiKey === "string" && apiKey.length > 0) {
+        return { apiKey, providerApiKeys: { [model.provider]: apiKey }, present: true, source: "pi_auth" };
+      }
+      return { present: true, source: "pi_auth" };
+    }
+  } catch {}
   const envKeys = findEnvKeys(model.provider);
   if (envKeys !== undefined && envKeys.length > 0) {
     for (const key of envKeys) {
@@ -27450,21 +27360,102 @@ function resolveRoleAuth(model, fromLocal, local, providerApiKeys, configuredEnd
     }
     return { present: false, source: "none", envName: envKeys[0] };
   }
-  const catalogKey = getEnvApiKey(model.provider);
-  if (catalogKey !== undefined) {
+  if (getEnvApiKey(model.provider) !== undefined) {
     return { present: true, source: "catalog" };
   }
   return { present: false, source: "none", envName: providerApiKeyEnvName(model.provider) };
 }
+async function resolveAgentModelCore(config, options = {}) {
+  const env = options.env ?? process.env;
+  const runtime = options.runtime ?? await getModelRuntime(resolveAgentDir(options));
+  const modelRef = config.model;
+  if (modelRef !== undefined && isConfiguredEndpoint(modelRef)) {
+    const catalogModel = resolveRuntimeCatalogModel(runtime, modelRef);
+    const model = catalogModel ?? buildModelFromConfiguredEndpoint(modelRef);
+    return {
+      model,
+      modelRef,
+      fromLocal: false,
+      configuredEndpoint: true,
+      catalog: catalogModel !== undefined,
+      local: undefined,
+      env,
+      auth: resolveConfiguredEndpointAuth(modelRef, model, env)
+    };
+  }
+  const registered = resolveBuiltInModel(runtime, modelRef);
+  if (registered !== undefined) {
+    return {
+      model: registered,
+      modelRef,
+      fromLocal: false,
+      configuredEndpoint: false,
+      catalog: true,
+      local: undefined,
+      env,
+      auth: await resolveCatalogAuth(runtime, registered, env)
+    };
+  }
+  if (modelRef === undefined) {
+    const piDefault = await resolvePiDefaultModel(runtime, options);
+    if (piDefault !== undefined) {
+      return {
+        model: piDefault,
+        modelRef,
+        fromLocal: false,
+        configuredEndpoint: false,
+        catalog: true,
+        local: undefined,
+        env,
+        auth: await resolveCatalogAuth(runtime, piDefault, env)
+      };
+    }
+    const local = loadLocalAutoRAGModel(localFallbackOptions(options, undefined));
+    return {
+      model: local.model,
+      modelRef,
+      fromLocal: true,
+      configuredEndpoint: false,
+      catalog: false,
+      local,
+      env,
+      auth: localRuntimeAuth(local)
+    };
+  }
+  const local = loadLocalAutoRAGModel(localFallbackOptions(options, modelRef.id));
+  const fromLocal = modelRef.provider === local.provider;
+  const model = fromLocal ? local.model : resolveRegisteredModel(runtime, modelRef);
+  return {
+    model,
+    modelRef,
+    fromLocal,
+    configuredEndpoint: false,
+    catalog: !fromLocal,
+    local: fromLocal ? local : undefined,
+    env,
+    auth: fromLocal ? localRuntimeAuth(local) : await resolveCatalogAuth(runtime, model, env)
+  };
+}
+async function resolveAgentModel(config, options = {}) {
+  const core = await resolveAgentModelCore(config, options);
+  return {
+    model: core.model,
+    ...core.auth.apiKey !== undefined ? { apiKey: core.auth.apiKey } : {},
+    ...core.auth.providerApiKeys !== undefined ? { providerApiKeys: core.auth.providerApiKeys } : {}
+  };
+}
+function providerApiKeyEnvName(provider) {
+  return `${provider.replace(/[^A-Za-z0-9_]/g, "_").toUpperCase()}_API_KEY`;
+}
 function resolveRoleSource(ref, fromLocal, configuredEndpoint, catalog) {
-  if (ref === undefined)
-    return "local_runtime";
   if (configuredEndpoint)
     return "config";
   if (fromLocal)
     return "mixed";
   if (catalog)
     return "catalog";
+  if (ref === undefined)
+    return "local_runtime";
   return "config";
 }
 function buildResolvedRole(model, auth, resolutionSource) {
@@ -27481,14 +27472,18 @@ function buildResolvedRole(model, auth, resolutionSource) {
     resolutionSource
   };
 }
-function resolveAgentModelDetailed(config, localOptions = {}) {
-  const core = resolveAgentModelCore(config, localOptions);
-  const auth = resolveRoleAuth(core.model, core.fromLocal, core.local, core.providerApiKeys, core.configuredEndpoint, core.modelRef !== undefined ? configuredApiKeyEnv(core.modelRef) : undefined, core.env);
+async function resolveAgentModelDetailed(config, options = {}) {
+  const core = await resolveAgentModelCore(config, options);
+  const auth = {
+    present: core.auth.present,
+    source: core.auth.source,
+    ...core.auth.envName !== undefined ? { envName: core.auth.envName } : {}
+  };
   const source = resolveRoleSource(core.modelRef, core.fromLocal, core.configuredEndpoint, core.catalog);
   return {
     model: core.model,
-    ...core.apiKey !== undefined ? { apiKey: core.apiKey } : {},
-    ...core.providerApiKeys !== undefined ? { providerApiKeys: core.providerApiKeys } : {},
+    ...core.auth.apiKey !== undefined ? { apiKey: core.auth.apiKey } : {},
+    ...core.auth.providerApiKeys !== undefined ? { providerApiKeys: core.auth.providerApiKeys } : {},
     role: buildResolvedRole(core.model, auth, source)
   };
 }
@@ -27502,7 +27497,7 @@ function writeConfigObject(path, config) {
   if (config === null || typeof config !== "object" || Array.isArray(config)) {
     throw new ConfigError("Config file must be a JSON object");
   }
-  mkdirSync24(dirname22(path), { recursive: true });
+  mkdirSync24(dirname21(path), { recursive: true });
   const contents = `${JSON.stringify(config, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -27515,7 +27510,7 @@ function writeConfigObject(path, config) {
 function writeDefaultConfig(path, partial, opts = {}) {
   const cwd = resolve15(opts.cwd ?? process.cwd());
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", cwd);
-  const memoryPath = partial.memoryPath === undefined ? join33(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
+  const memoryPath = partial.memoryPath === undefined ? join34(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
   const full = {
     searchPaths: resolveSearchPaths(partial.searchPaths ?? ["."], cwd),
     workspacePath,
@@ -27546,7 +27541,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
     full.p2p = normalizeP2pConfig(partial.p2p);
   else
     full.p2p = { enabled: false };
-  mkdirSync24(dirname22(path), { recursive: true });
+  mkdirSync24(dirname21(path), { recursive: true });
   const contents = `${JSON.stringify(full, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -27569,7 +27564,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
     lock.release();
   }
 }
-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, 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, 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.";
+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, 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, 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(() => {
   init_local_model();
   init_home();
@@ -27647,6 +27642,7 @@ var init_config2 = __esm(() => {
     sectionLimit: true
   };
   RERANK_ALLOWLIST = new Set(["enabled", "provider", "model", "apiKeyEnv", "baseUrl", "topN", "timeoutMs"]);
+  modelRuntimeCache = new Map;
 });
 
 // src/core.ts