@autorag/librarian 2.6.3 → 2.7.0

package/dist/cli/index.js

@@ -10488,8 +10488,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);
 }
 
@@ -10518,8 +10519,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;
@@ -10548,7 +10549,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 = [];
@@ -10578,8 +10579,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/types.ts
 function isSearchProviderId(value) {
@@ -10679,7 +10682,8 @@ var init_types4 = __esm(() => {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync9, mkdirSync as mkdirSync10, readFileSync as readFileSync10, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync8 } from "node:fs";
 import { basename as basename7, dirname as dirname10, isAbsolute as isAbsolute4, join as join13, resolve as resolve6 } from "node:path";
-import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
+import { findEnvKeys, getEnvApiKey } from "@earendil-works/pi-ai/compat";
+import { getAgentDir, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
 function resolveConfigPath(input) {
   const flags = input.flags;
   const env = input.env ?? process.env;
@@ -11402,6 +11406,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`);
@@ -11533,12 +11540,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 } : {},
@@ -11550,109 +11552,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 ?? getAgentDir();
+}
+function getModelRuntime(agentDir) {
+  const cached = modelRuntimeCache.get(agentDir);
+  if (cached !== undefined)
+    return cached;
+  const created = ModelRuntime.create({
+    authPath: join13(agentDir, "auth.json"),
+    modelsPath: join13(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 = SettingsManager.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) {
@@ -11667,21 +11680,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) {
@@ -11698,14 +11792,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)
   };
 }
@@ -11786,7 +11884,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_PATTERN, 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_PATTERN, 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();
@@ -11864,6 +11962,7 @@ var init_config2 = __esm(() => {
     sectionLimit: true
   };
   RERANK_ALLOWLIST = new Set(["enabled", "provider", "model", "apiKeyEnv", "baseUrl", "topN", "timeoutMs"]);
+  modelRuntimeCache = new Map;
 });
 
 // src/cli/commands/init.ts
@@ -17571,392 +17670,9 @@ var init_model_auth = __esm(() => {
   };
 });
 
-// src/filesystem/cloud-placeholder.ts
-import { execFile as execFile3 } from "node:child_process";
-import { lstat } from "node:fs/promises";
-import { dirname as dirname18, 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 = dirname18(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(execFile3);
-  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 spawn18 } 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 = spawn18(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 = spawn18("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_MS10;
-  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_MS10 = 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}`;
 }
@@ -18002,15 +17718,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,
@@ -18129,11 +17845,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,
@@ -18186,55 +17902,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,
@@ -18286,28 +18002,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}).`
     }))
@@ -18315,7 +18031,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,
@@ -18349,29 +18065,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,
@@ -18427,27 +18143,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}).`
     }))
@@ -18455,7 +18171,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,
@@ -18576,10 +18292,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." }))
   });
 });
 
@@ -18594,7 +18310,7 @@ import {
   watch,
   writeFileSync as writeFileSync17
 } from "node:fs";
-import { dirname as dirname19, join as join29 } from "node:path";
+import { dirname as dirname18, join as join29 } from "node:path";
 function requestsDir(workspacePath) {
   return join29(workspacePath, P2P_DIR, "requests");
 }
@@ -18611,7 +18327,7 @@ function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function atomicWrite(path, value) {
-  mkdirSync19(dirname19(path), { recursive: true });
+  mkdirSync19(dirname18(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
   writeFileSync17(tempPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -19017,7 +18733,7 @@ var init_egress_gate = __esm(() => {
 
 // src/p2p/policy.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync18 } from "node:fs";
-import { basename as basename13, dirname as dirname20, join as join30, resolve as resolve14 } from "node:path";
+import { basename as basename13, dirname as dirname19, join as join30, resolve as resolve14 } from "node:path";
 import { parse as parseToml } from "smol-toml";
 function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -19355,7 +19071,7 @@ class PolicyStore {
   }
   persistSeenSources() {
     try {
-      mkdirSync20(dirname20(this.seenSourcesPath), { recursive: true });
+      mkdirSync20(dirname19(this.seenSourcesPath), { recursive: true });
       writeFileSync18(this.seenSourcesPath, `${JSON.stringify({
         sources: [...this.seenSources].sort(),
         pending: [...this.pendingSources].sort()
@@ -19501,57 +19217,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.)"
     })
   });
@@ -19560,7 +19276,7 @@ var init_wire = __esm(() => {
 // src/p2p/simplex-query-store.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { existsSync as existsSync26, mkdirSync as mkdirSync21, readdirSync as readdirSync5, readFileSync as readFileSync21, renameSync as renameSync10, unlinkSync as unlinkSync5, writeFileSync as writeFileSync19 } from "node:fs";
-import { dirname as dirname21, join as join31 } from "node:path";
+import { dirname as dirname20, join as join31 } from "node:path";
 import { Value } from "typebox/value";
 function statePath(workspacePath, directory, id) {
   return join31(workspacePath, QUERY_DIR, directory, `${id}.json`);
@@ -19569,7 +19285,7 @@ function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function atomicWrite2(path, value) {
-  mkdirSync21(dirname21(path), { recursive: true });
+  mkdirSync21(dirname20(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   writeFileSync19(tempPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -19798,7 +19514,7 @@ var init_simplex_query_store = __esm(() => {
 // src/p2p/simplex-server.ts
 import { existsSync as existsSync27, mkdirSync as mkdirSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join32 } 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));
@@ -20112,11 +19828,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 = join32(".autorag", "p2p");
@@ -20129,7 +19845,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,
@@ -20158,17 +19874,216 @@ 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." })
+}
+var RECOMMEND_PEER_TARGETS_TOOL_NAME = "recommend_peer_targets", recommendPeerTargetsSchema;
+var init_peer_target_tool = __esm(() => {
+  init_simplex_server();
+  recommendPeerTargetsSchema = Type11.Object({
+    query: Type11.String({ description: "Question or topic to match against local peer personas." })
+  });
+});
+
+// src/agent/pi-session.ts
+import { join as join33 } from "node:path";
+import { streamSimple as compatStreamSimple } from "@earendil-works/pi-ai/compat";
+import {
+  createAgentSession,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  DefaultResourceLoader,
+  getAgentDir as getAgentDir2,
+  ModelRuntime as ModelRuntime2,
+  SessionManager,
+  SettingsManager as SettingsManager2
+} 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 ?? getAgentDir2();
+  const settingsManager = SettingsManager2.create(options.cwd, agentDir);
+  if (settingsManager.getDefaultTools() === undefined) {
+    settingsManager.applyOverrides({ defaultTools: [...PI_BUILTIN_TOOL_NAMES] });
+  }
+  const modelRuntime = await ModelRuntime2.create({
+    authPath: join33(agentDir, "auth.json"),
+    modelsPath: join33(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 ?? getAgentDir2();
+  const settingsManager = SettingsManager2.create(options.cwd, agentDir);
+  if (settingsManager.getDefaultTools() === undefined) {
+    settingsManager.applyOverrides({ defaultTools: [...PI_BUILTIN_TOOL_NAMES] });
+  }
+  const modelRuntime = await ModelRuntime2.create({
+    authPath: join33(agentDir, "auth.json"),
+    modelsPath: join33(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 failure4(alias, message) {
   const details = { method: "query_peer_agent", ok: false, alias, message };
   return { content: [{ type: "text", text: message }], details };
@@ -20273,18 +20188,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 randomUUID8 } from "node:crypto";
 import { mkdirSync as mkdirSync23, readFileSync as readFileSync23, renameSync as renameSync11, rmSync as rmSync7, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname22 } from "node:path";
+import { dirname as dirname21 } from "node:path";
 function readRefreshProgress(root) {
   try {
     const parsed = JSON.parse(readFileSync23(refreshProgressPath(root), "utf8"));
@@ -20298,7 +20213,7 @@ function readRefreshProgress(root) {
 }
 function writeRefreshProgress(root, progress) {
   const path = refreshProgressPath(root);
-  mkdirSync23(dirname22(path), { recursive: true });
+  mkdirSync23(dirname21(path), { recursive: true });
   const temporaryPath = `${path}.${randomUUID8()}.tmp`;
   try {
     writeFileSync21(temporaryPath, `${JSON.stringify(progress, null, 2)}
@@ -20521,7 +20436,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,
@@ -20574,17 +20489,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,
@@ -20655,17 +20570,17 @@ ${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/**." }))
   });
 });
 
 // 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));
 }
@@ -20729,10 +20644,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." }))
   });
 });
 
@@ -21245,7 +21160,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 join33 } from "node:path";
+import { join as join34 } from "node:path";
 function combineSignals3(signal, timeoutMs) {
   if (!signal)
     return AbortSignal.timeout(timeoutMs);
@@ -21321,8 +21236,8 @@ async function convertBinaryPayload(buffer, extension, _finalUrl, signal) {
   if (!parser) {
     return { content: "", ok: false, error: `No parser registered for ${ext}` };
   }
-  const tempDir = await mkdtemp2(join33(tmpdir2(), "autorag-fetch-"));
-  const tempPath = join33(tempDir, `payload${ext}`);
+  const tempDir = await mkdtemp2(join34(tmpdir2(), "autorag-fetch-"));
+  const tempPath = join34(tempDir, `payload${ext}`);
   try {
     await writeFile3(tempPath, buffer);
     const input = {
@@ -22881,7 +22796,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(`
 `);
@@ -22978,9 +22893,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." }))
   });
 });
 
@@ -26406,7 +26321,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,
@@ -26476,24 +26391,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 randomUUID9 } from "node:crypto";
 import { existsSync as existsSync29, watch as fsWatch, mkdirSync as mkdirSync24, realpathSync as realpathSync5, statSync, writeFileSync as writeFileSync22 } from "node:fs";
-import { basename as basename14, dirname as dirname23, join as join34, resolve as resolve15 } from "node:path";
-import { Agent } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
+import { basename as basename14, dirname as dirname22, join as join35, resolve as resolve15 } 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;
@@ -26510,9 +26424,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;
@@ -26553,6 +26464,7 @@ class AutoRAGAgent {
   sessions = new Map;
   activeRun = false;
   resultCapture;
+  interactiveFastAnswerCallback;
   modelNativeSearchAuth;
   retrievalTrace = [];
   preliminaryCallback;
@@ -26601,6 +26513,10 @@ class AutoRAGAgent {
   droppedCallerToolNames;
   searchTimeoutMs;
   maxSearchToolCalls;
+  piAgentDir;
+  piSessionDir;
+  persistPiSessions;
+  boundPiRuntime;
   remoteSession;
   activeRetrievalOptions;
   searchToolCallCount = 0;
@@ -26622,6 +26538,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}`));
@@ -26682,10 +26601,10 @@ class AutoRAGAgent {
       if (fsearchClient.isSupported())
         this.fsearchClient = fsearchClient;
     }
-    const memPath = memoryPath ?? join34(resolveAutoRAGHome(), "memory.json");
+    const memPath = memoryPath ?? join35(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
-    this.runLogger = new AutoRAGRunLogger(join34(dirname23(memPath), "logs", "runs.jsonl"));
+    this.runLogger = new AutoRAGRunLogger(join35(dirname22(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)]);
@@ -26694,16 +26613,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 ?? join34(this.workspaceProjectRoot, ".autorag", "p2p", "simplex"),
+        dbPrefix: peerQuery?.simplexDbPrefix ?? join35(this.workspaceProjectRoot, ".autorag", "p2p", "simplex"),
         displayName: `autorag-${basename14(this.workspaceProjectRoot) || "node"}`
       })),
       autoStart: true,
@@ -26717,7 +26633,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,
@@ -26744,7 +26660,6 @@ class AutoRAGAgent {
     });
     this.droppedCallerToolNames = [...new Set(droppedCallerToolNames)];
     const orderedTools = [
-      ...bashTool !== undefined ? [bashTool] : [],
       ...callerTools,
       checkMemoryTool,
       searchMinSyncTool,
@@ -26769,7 +26684,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,
@@ -26780,28 +26695,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 });
     }
@@ -26842,7 +26743,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,
@@ -26857,19 +26767,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) {
@@ -26920,6 +26851,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();
   }
@@ -27002,14 +26982,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 } : {},
@@ -27024,7 +27011,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;
@@ -27042,28 +27029,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));
             }
@@ -27192,6 +27186,8 @@ ${initialRetrievalContext}`);
       this.resultCapture = undefined;
       this.activeRetrievalOptions = undefined;
       this.preliminaryCallback = undefined;
+      if (this.interactiveFastAnswerCallback === emitPreliminary)
+        this.interactiveFastAnswerCallback = undefined;
       this.activeRun = false;
     }
   }
@@ -27588,7 +27584,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         lastError: undefined
       };
       if (needsParsed) {
-        mkdirSync24(dirname23(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
+        mkdirSync24(dirname22(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
         writeFileSync22(refreshReadinessPath(this.workspaceProjectRoot), `{"version":1,"completed":true,"parsed":true}
 `);
       }
@@ -27800,7 +27796,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
       written: 0,
       deleted: 0,
       skipped: 0,
-      indexPath: join34(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
+      indexPath: join35(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
       diagnostics
     };
   }
@@ -28346,7 +28342,7 @@ function toMinSyncReasonDiagnostic(reason) {
 function pinExcludedPath(path) {
   const resolvedPath = resolve15(path);
   try {
-    return join34(realpathSync5(dirname23(resolvedPath)), basename14(resolvedPath));
+    return join35(realpathSync5(dirname22(resolvedPath)), basename14(resolvedPath));
   } catch {
     return resolvedPath;
   }
@@ -28407,7 +28403,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();
@@ -28417,6 +28412,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();
@@ -28626,7 +28622,7 @@ async function runSearch(ctx, deps = {}) {
   } else {
     let resolvedModel;
     try {
-      resolvedModel = (deps.modelResolver ?? resolveAgentModel)(config);
+      resolvedModel = await (deps.modelResolver ?? resolveAgentModel)(config);
     } catch (error) {
       const hint = classifySearchHealthHint(error);
       ctx.stderr(renderError(error, { json: ctx.json, debug: ctx.debug, hint }));
@@ -28855,7 +28851,7 @@ var init_memory2 = __esm(() => {
 
 // src/cli/commands/index.ts
 import { existsSync as existsSync30, lstatSync as lstatSync3, rmSync as rmSync8 } from "node:fs";
-import { join as join35, resolve as resolve16, sep as sep8 } from "node:path";
+import { join as join36, resolve as resolve16, sep as sep7 } from "node:path";
 async function runIndex(ctx) {
   const sub = ctx.positionals[0];
   if (sub !== "reset" && sub !== "rebuild") {
@@ -28889,7 +28885,7 @@ async function runIndex(ctx) {
   }
   if (!ctx.flags.yes) {
     if (ctx.promptYesNo) {
-      const ok = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join35(config.workspacePath, ".autorag")}?`);
+      const ok = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join36(config.workspacePath, ".autorag")}?`);
       if (!ok) {
         ctx.stderr(renderError(new Error("Reset declined."), { json: ctx.json }));
         return 2;
@@ -28953,7 +28949,7 @@ function resolveResetScope(methods) {
   };
 }
 function isWithin(target, base) {
-  const prefix = base.endsWith(sep8) ? base : `${base}${sep8}`;
+  const prefix = base.endsWith(sep7) ? base : `${base}${sep7}`;
   return target === base || target.startsWith(prefix);
 }
 var ALL_RESET_TARGETS, ALL_RESET_TARGET_NAMES;
@@ -29045,7 +29041,7 @@ function sanitizeMessage(raw) {
 function parseTimeoutMs(flags) {
   const raw = flags["timeout-ms"];
   if (raw === undefined || raw === true)
-    return DEFAULT_TIMEOUT_MS11;
+    return DEFAULT_TIMEOUT_MS10;
   const text = typeof raw === "string" ? raw.trim() : "";
   if (!/^\d+$/.test(text) || Number(text) <= 0) {
     return `--timeout-ms must be a positive integer (got "${text}")`;
@@ -29159,7 +29155,7 @@ async function runHealth(ctx, deps = {}) {
   }
   let resolved;
   try {
-    const detailed = (deps.modelResolver ?? resolveAgentModelDetailed)(config);
+    const detailed = await (deps.modelResolver ?? resolveAgentModelDetailed)(config);
     resolved = detailed;
   } catch (error) {
     const report = {
@@ -29228,7 +29224,7 @@ async function runHealth(ctx, deps = {}) {
   ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
   return exitCode(probe.category);
 }
-var DEFAULT_TIMEOUT_MS11 = 1e4;
+var DEFAULT_TIMEOUT_MS10 = 1e4;
 var init_health = __esm(() => {
   init_config2();
 });
@@ -29290,289 +29286,8 @@ var init_duplicates = __esm(() => {
   init_config2();
 });
 
-// src/cli/tui-commands.ts
-function parseSlashCommand(input) {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("/"))
-    return;
-  const [rawName, ...args] = trimmed.slice(1).split(/\s+/u);
-  if (!rawName)
-    return { kind: "incomplete" };
-  if (rawName === "quit")
-    return { kind: "quit" };
-  if (rawName === "resume") {
-    const sessionId = args.join(" ").trim();
-    return { kind: "resume", sessionId: sessionId || undefined };
-  }
-  return { kind: "unknown", name: rawName };
-}
-function createTuiSlashCommands(store) {
-  return [
-    { name: "quit", description: "Exit the AutoRAG TUI" },
-    {
-      name: "resume",
-      description: "List or restore a previous TUI session",
-      argumentHint: "[number|session-id]",
-      getArgumentCompletions: (prefix) => {
-        const normalized = prefix.trim().toLowerCase();
-        return store.list().filter((session) => normalized.length === 0 || session.id.toLowerCase().includes(normalized) || session.query.toLowerCase().includes(normalized)).map((session) => ({
-          value: session.id,
-          label: session.id,
-          description: session.query
-        }));
-      }
-    }
-  ];
-}
-function renderSlashHelp() {
-  return "commands: /quit, /resume [session-id]";
-}
-
-// src/cli/tui-session-store.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync25, readFileSync as readFileSync24, renameSync as renameSync12, writeFileSync as writeFileSync23 } from "node:fs";
-import { dirname as dirname24 } from "node:path";
-function createFileTuiSessionStore(path) {
-  const readSessions = () => {
-    if (!existsSync31(path))
-      return [];
-    try {
-      const parsed = JSON.parse(readFileSync24(path, "utf8"));
-      if (!Array.isArray(parsed))
-        return [];
-      return parsed.filter(isTuiSessionRecord).sort((a, b) => b.updatedAt - a.updatedAt);
-    } catch {
-      return [];
-    }
-  };
-  return {
-    list: readSessions,
-    get: (id) => readSessions().find((session) => session.id === id),
-    save: (session) => {
-      const sessions = readSessions().filter((item) => item.id !== session.id);
-      sessions.unshift(session);
-      const dir = dirname24(path);
-      mkdirSync25(dir, { recursive: true });
-      const tmpPath = `${path}.${process.pid}.tmp`;
-      writeFileSync23(tmpPath, `${JSON.stringify(sessions.slice(0, MAX_SESSIONS), null, 2)}
-`, "utf8");
-      renameSync12(tmpPath, path);
-    }
-  };
-}
-function createMergedTuiSessionStore(...stores) {
-  return {
-    list: () => {
-      const sessions = new Map;
-      for (const store of stores) {
-        for (const session of store.list()) {
-          const current = sessions.get(session.id);
-          if (current === undefined || session.updatedAt > current.updatedAt) {
-            sessions.set(session.id, session);
-          }
-        }
-      }
-      return [...sessions.values()].sort((a, b) => b.updatedAt - a.updatedAt);
-    },
-    get: (id) => {
-      const matches = stores.flatMap((store) => store.list()).filter((session) => session.id === id).sort((a, b) => b.updatedAt - a.updatedAt);
-      return matches[0];
-    },
-    save: (session) => {
-      for (const store of stores)
-        store.save(session);
-    }
-  };
-}
-function renderTuiSessionList(sessions) {
-  if (sessions.length === 0)
-    return "resume: no saved sessions";
-  return [
-    "resume sessions:",
-    ...sessions.map((session, index) => `  ${index + 1}. ${session.query}  [${session.id}]`),
-    "enter the session number to restore it"
-  ].join(`
-`);
-}
-function renderRestoredTuiSession(session) {
-  return [`resumed: ${session.id}`, `> ${session.query}`, session.answer, "--- restored trace ---", session.trace].filter((line) => line.length > 0).join(`
-`);
-}
-function isTuiSessionRecord(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const record = value;
-  return typeof record.id === "string" && typeof record.query === "string" && typeof record.answer === "string" && typeof record.trace === "string" && typeof record.updatedAt === "number";
-}
-var MAX_SESSIONS = 100;
-var init_tui_session_store = () => {};
-
 // src/cli/commands/tui.ts
-import { join as join36 } from "node:path";
-import {
-  CombinedAutocompleteProvider,
-  Editor,
-  ProcessTerminal,
-  Text,
-  TuiMainScreen
-} from "@earendil-works/pi-tui";
-function createTuiPresenter() {
-  const output = [];
-  let thinkingIndex;
-  let answer = "";
-  let active = false;
-  let paused = false;
-  let suppressEvents = false;
-  const lifecycleRows = new Map;
-  let statusText = "ready";
-  const append = (line) => {
-    output.push(line);
-  };
-  const appendDelta = (prefix, delta, index) => {
-    if (index === "answer") {
-      answer = `${answer.length === 0 ? prefix : answer}${delta}`;
-      return;
-    }
-    const currentIndex = thinkingIndex;
-    if (currentIndex === undefined) {
-      append(dimGray(`${prefix}${delta}`));
-      thinkingIndex = output.length - 1;
-      return;
-    }
-    output[currentIndex] = dimGray(`${stripAnsi(output[currentIndex])}${delta}`);
-  };
-  const updateLifecycle = (key, started, completed) => {
-    const index = lifecycleRows.get(key);
-    if (index === undefined) {
-      lifecycleRows.set(key, output.length);
-      append(started);
-      return;
-    }
-    output[index] = completed;
-  };
-  return {
-    working: () => active,
-    status: () => statusText,
-    reset: () => {
-      output.length = 0;
-      thinkingIndex = undefined;
-      answer = "";
-      active = false;
-      paused = false;
-      suppressEvents = false;
-      lifecycleRows.clear();
-      statusText = "ready";
-    },
-    setWorking: (value) => {
-      active = value;
-      statusText = value ? "working..." : "completed.";
-    },
-    beginRun: () => {
-      active = true;
-      statusText = "working...";
-      paused = false;
-      suppressEvents = false;
-    },
-    interrupt: () => {
-      active = false;
-      statusText = "stopped.";
-      paused = true;
-      suppressEvents = true;
-    },
-    handle(event) {
-      if (suppressEvents)
-        return;
-      switch (event.type) {
-        case "agent_start":
-          active = true;
-          statusText = "working...";
-          paused = false;
-          return;
-        case "agent_end":
-          active = false;
-          statusText = "completed.";
-          return;
-        case "turn_start":
-          return;
-        case "turn_end":
-          return;
-        case "message_start":
-          return;
-        case "message_end":
-          return;
-        case "message_update": {
-          const streamEvent = event.assistantMessageEvent;
-          if (streamEvent.type === "thinking_start") {
-            thinkingIndex = undefined;
-          } else if (streamEvent.type === "thinking_delta") {
-            appendDelta("thinking: ", streamEvent.delta, "thinking");
-          } else if (streamEvent.type === "thinking_end" && thinkingIndex !== undefined) {
-            output[thinkingIndex] = dimGray("thinking: (collapsed)");
-            thinkingIndex = undefined;
-          } else if (streamEvent.type === "text_start") {
-            answer = "";
-          } else if (streamEvent.type === "text_delta") {
-            appendDelta("assistant: ", streamEvent.delta, "answer");
-          }
-          return;
-        }
-        case "tool_execution_start":
-          updateLifecycle(`tool:${event.toolCallId}`, `${event.toolName}: searching`, `✓ ${event.toolName}: done`);
-          return;
-        case "tool_execution_update":
-          updateLifecycle(`tool:${event.toolCallId}`, `${event.toolName}: searching`, `${event.toolName}: searching`);
-          return;
-        case "tool_execution_end":
-          updateLifecycle(`tool:${event.toolCallId}`, `${event.toolName}: searching`, `${event.isError ? "✗" : "✓"} ${event.toolName}: ${event.isError ? "error" : "done"}`);
-          return;
-      }
-    },
-    lines: () => (paused ? ["paused"] : []).concat(output, answer.length > 0 ? [answer] : [])
-  };
-}
-function dimGray(text) {
-  return `${ANSI_DIM_GRAY}${text}${ANSI_RESET}`;
-}
-function renderProgressEvent(event) {
-  return event.type === "progress" && event.text.trim() !== "" ? event.text : undefined;
-}
-async function consumeSearchStream(agent, query, handlers) {
-  for await (const event of agent.searchDocumentsStream(query)) {
-    if (handlers.isInterrupted?.())
-      return;
-    switch (event.type) {
-      case "progress": {
-        const progress = renderProgressEvent(event);
-        if (progress !== undefined)
-          handlers.onProgress(progress);
-        break;
-      }
-      case "preliminary":
-        handlers.onPreliminary?.(event.response);
-        break;
-      case "complete":
-        handlers.onComplete(event.response);
-        break;
-    }
-  }
-}
-function stripAnsi(text) {
-  return text.replace(/\u001b\[[0-9;]*m/g, "");
-}
-function createAgent(ctx, deps) {
-  const thinking = parseThinkingFlags(ctx.flags);
-  if (deps.agentFactory)
-    return deps.agentFactory(thinking === undefined ? undefined : { thinking });
-  const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
-  const resolvedModel = (deps.modelResolver ?? resolveAgentModel)(config);
-  const options = {
-    ...buildAgentOptions(config),
-    model: resolvedModel.model,
-    ...resolvedModel.apiKey !== undefined ? { apiKey: resolvedModel.apiKey } : {},
-    ...resolvedModel.providerApiKeys !== undefined ? { providerApiKeys: resolvedModel.providerApiKeys } : {},
-    ...thinking !== undefined ? { thinking } : {}
-  };
-  return new AutoRAGAgent(options);
-}
+import { InteractiveMode } from "@earendil-works/pi-coding-agent";
 function parseThinkingFlags(flags) {
   if (flags["single-phase"] === true)
     return false;
@@ -29589,366 +29304,50 @@ function parseThinkingFlags(flags) {
     return;
   return { ...fast !== undefined ? { fast } : {}, ...final !== undefined ? { final } : {} };
 }
-function createRealTui() {
-  return new TuiMainScreen(new ProcessTerminal);
-}
-function sessionForSelection(store, input) {
-  const sessions = store.list();
-  const index = Number.parseInt(input, 10);
-  if (Number.isInteger(index) && index > 0)
-    return sessions[index - 1];
-  return store.get(input);
-}
-function renderTuiSessionView(session, input) {
-  const content = session === undefined ? `resume: session not found: ${input}` : renderRestoredTuiSession(session);
-  return `${TUI_TITLE}
-
-${content}`;
-}
-function defaultSessionStore(ctx) {
+async function createTuiAgent(ctx) {
   const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
-  const workspace = createFileTuiSessionStore(join36(config.workspacePath, ".autorag", "tui-sessions.json"));
-  const global = createFileTuiSessionStore(join36(resolveAutoRAGHome(), "tui-sessions.json"));
-  return createMergedTuiSessionStore(workspace, global);
-}
-function runRealTui(ctx, agent, store) {
-  const tui = createRealTui();
-  let transcriptHistory = TUI_TITLE;
-  const transcript = new Text(transcriptHistory);
-  const presenter = createTuiPresenter();
-  let finalAnswer = "";
-  const renderTranscript = () => {
-    const trace = presenter.lines();
-    const sections = [
-      transcriptHistory,
-      trace.length > 0 ? `--- live trace ---
-${trace.join(`
-`)}` : "",
-      finalAnswer
-    ];
-    transcript.setText(sections.filter((section) => section.length > 0).join(`
-
-`));
-  };
-  const status = new Text(presenter.status());
-  const renderStatus = () => {
-    status.setText(presenter.status());
-  };
-  const editor = new Editor(tui, {
-    borderColor: (value) => value,
-    selectList: {
-      selectedPrefix: (value) => value,
-      selectedText: (value) => value,
-      description: (value) => value,
-      scrollInfo: (value) => value,
-      noMatch: (value) => value
-    }
-  });
-  editor.setAutocompleteProvider(new CombinedAutocompleteProvider(createTuiSlashCommands(store), ctx.cwd));
-  let settled = false;
-  let queryRunning = false;
-  let interrupted = false;
-  let resumeSelection = false;
-  let completedResponse;
-  let completedAnswer = "";
-  return new Promise((resolve) => {
-    const finish = () => {
-      if (settled)
-        return;
-      settled = true;
-      unsubscribe?.();
-      tui.stop();
-      stopRuntime().catch(() => {
-        return;
-      }).finally(() => resolve(0));
-    };
-    const unsubscribe = agent.subscribe?.((event) => {
-      presenter.handle(event);
-      renderStatus();
-      renderTranscript();
-      tui.requestRender();
-    });
-    const handleInput = (data) => {
-      if (data === "\x03") {
-        if (queryRunning) {
-          interrupted = true;
-          presenter.interrupt();
-          agent.abort?.();
-          transcriptHistory = `${transcriptHistory}
-interrupted`;
-        } else {
-          presenter.interrupt();
-          transcriptHistory = `${transcriptHistory}
-paused`;
-        }
-        renderStatus();
-        renderTranscript();
-        tui.requestRender();
-        return;
-      }
-      if (data === "\x04")
-        finish();
-    };
-    editor.onSubmit = (raw) => {
-      const query = raw.trim();
-      editor.setText("");
-      if (query.length === 0)
-        return;
-      if (resumeSelection && !query.startsWith("/")) {
-        resumeSelection = false;
-        const session = sessionForSelection(store, query);
-        presenter.reset();
-        finalAnswer = "";
-        transcriptHistory = renderTuiSessionView(session, query);
-        renderTranscript();
-        tui.requestRender();
-        return;
-      }
-      resumeSelection = false;
-      const command = parseSlashCommand(query);
-      if (command !== undefined) {
-        if (command.kind === "quit") {
-          finish();
-          return;
-        }
-        if (command.kind === "incomplete" || command.kind === "unknown") {
-          transcriptHistory = `${transcriptHistory}
-
-${command.kind === "unknown" ? `unknown command: /${command.name}` : renderSlashHelp()}`;
-          renderTranscript();
-          tui.requestRender();
-          return;
-        }
-        if (command.sessionId === undefined) {
-          presenter.reset();
-          finalAnswer = "";
-          resumeSelection = store.list().length > 0;
-          transcriptHistory = `${TUI_TITLE}
-
-${renderTuiSessionList(store.list())}`;
-        } else {
-          const session = sessionForSelection(store, command.sessionId);
-          presenter.reset();
-          finalAnswer = "";
-          transcriptHistory = renderTuiSessionView(session, command.sessionId);
-        }
-        renderTranscript();
-        tui.requestRender();
-        return;
-      }
-      queryRunning = true;
-      interrupted = false;
-      presenter.beginRun();
-      editor.disableSubmit = true;
-      presenter.setWorking(true);
-      renderStatus();
-      finalAnswer = "";
-      transcriptHistory = `${transcriptHistory}
-
-> ${query}`;
-      renderTranscript();
-      tui.requestRender();
-      consumeSearchStream(agent, query, {
-        onProgress: (progress) => {
-          transcriptHistory = `${transcriptHistory}
-
-${progress}`;
-          renderTranscript();
-          tui.requestRender();
-        },
-        onPreliminary: (response) => {
-          transcriptHistory = `${transcriptHistory}
-
-${renderPreliminary(response, {
-            json: false,
-            debug: ctx.debug
-          })}`;
-          renderTranscript();
-          tui.requestRender();
-        },
-        onComplete: (response) => {
-          const answer = renderSearch(response, { json: false, debug: ctx.debug });
-          completedResponse = response;
-          completedAnswer = answer;
-          finalAnswer = answer;
-          renderTranscript();
-          tui.requestRender();
-        },
-        isInterrupted: () => interrupted
-      }).catch((error) => {
-        if (interrupted)
-          return;
-        transcriptHistory = `${transcriptHistory}
-
-${renderError(error, {
-          json: false,
-          debug: ctx.debug
-        })}`;
-        renderTranscript();
-      }).finally(() => {
-        queryRunning = false;
-        presenter.setWorking(false);
-        renderStatus();
-        if (completedResponse !== undefined) {
-          store.save({
-            id: completedResponse.sessionId,
-            query,
-            answer: completedAnswer,
-            trace: presenter.lines().join(`
-`),
-            updatedAt: Date.now()
-          });
-          completedResponse = undefined;
-        }
-        renderTranscript();
-        editor.disableSubmit = false;
-        tui.requestRender();
-      });
-    };
-    tui.addChild(transcript);
-    tui.addChild(status);
-    tui.addChild(editor);
-    tui.setFocus(editor);
-    tui.addInputListener((data) => {
-      handleInput(data);
-      return { consume: data === "\x03" || data === "\x04" };
-    });
-    tui.start();
-  });
+  const options = { ...buildAgentOptions(config) };
+  const thinking = parseThinkingFlags(ctx.flags);
+  if (thinking !== undefined)
+    options.thinking = thinking;
+  if (config.model !== undefined) {
+    const resolved = await resolveAgentModel(config);
+    options.model = resolved.model;
+    if (resolved.apiKey !== undefined)
+      options.apiKey = resolved.apiKey;
+    if (resolved.providerApiKeys !== undefined)
+      options.providerApiKeys = resolved.providerApiKeys;
+  }
+  return new AutoRAGAgent(options);
 }
-async function runTui(ctx, deps = {}) {
+async function runTui(ctx) {
   try {
-    const agent = createAgent(ctx, deps);
-    const store = deps.sessionStore ?? defaultSessionStore(ctx);
-    if (!deps.tuiFactory)
-      return runRealTui(ctx, agent, store);
-    const tui = deps.tuiFactory(ctx);
-    const presenter = createTuiPresenter();
-    let queryRunning = false;
-    let interrupted = false;
-    let resumeSelection = false;
-    let completedResponse;
-    let completedAnswer = "";
-    const unsubscribe = agent.subscribe?.((event) => {
-      presenter.handle(event);
-      tui.rendered.push(presenter.lines().join(`
-`));
-      tui.onEvent?.(event);
-    });
-    tui.onSubmit = async (raw) => {
-      const query = raw.trim();
-      if (query.length === 0)
-        return;
-      if (resumeSelection && !query.startsWith("/")) {
-        resumeSelection = false;
-        const session = sessionForSelection(store, query);
-        presenter.reset();
-        tui.rendered.length = 0;
-        tui.rendered.push(session === undefined ? `resume: session not found: ${query}` : renderRestoredTuiSession(session));
-        return;
-      }
-      resumeSelection = false;
-      const command = parseSlashCommand(query);
-      if (command !== undefined) {
-        if (command.kind === "quit") {
-          tui.onExit?.();
-          return;
-        }
-        if (command.kind === "incomplete") {
-          tui.rendered.push(renderSlashHelp());
-        } else if (command.kind === "unknown") {
-          tui.rendered.push(`unknown command: /${command.name}`);
-        } else if (command.sessionId === undefined) {
-          presenter.reset();
-          tui.rendered.length = 0;
-          resumeSelection = store.list().length > 0;
-          tui.rendered.push(renderTuiSessionList(store.list()));
-        } else {
-          const session = sessionForSelection(store, command.sessionId);
-          presenter.reset();
-          tui.rendered.length = 0;
-          tui.rendered.push(session === undefined ? `resume: session not found: ${command.sessionId}` : renderRestoredTuiSession(session));
-        }
-        return;
-      }
-      queryRunning = true;
-      interrupted = false;
-      presenter.beginRun();
-      try {
-        await consumeSearchStream(agent, query, {
-          onProgress: (progress) => {
-            tui.rendered.push(progress);
-          },
-          onPreliminary: (response) => {
-            tui.rendered.push(renderPreliminary(response, { json: false, debug: ctx.debug }));
-          },
-          onComplete: (response) => {
-            const answer = renderSearch(response, { json: false, debug: ctx.debug });
-            tui.rendered.push(answer);
-            completedResponse = response;
-            completedAnswer = answer;
-          },
-          isInterrupted: () => interrupted
-        });
-      } catch (error) {
-        if (!interrupted) {
-          tui.rendered.push(renderError(error, { json: false, debug: ctx.debug }));
-        }
-      } finally {
-        queryRunning = false;
-        presenter.setWorking(false);
-        if (completedResponse !== undefined) {
-          store.save({
-            id: completedResponse.sessionId,
-            query,
-            answer: completedAnswer,
-            trace: presenter.lines().join(`
-`),
-            updatedAt: Date.now()
-          });
-          completedResponse = undefined;
-        }
-      }
-    };
-    tui.onInput = (data) => {
-      if (data === "\x03") {
-        if (queryRunning) {
-          interrupted = true;
-          presenter.interrupt();
-          agent.abort?.();
-          tui.rendered.push("interrupted");
-        } else {
-          presenter.interrupt();
-          tui.rendered.push("paused");
-        }
+    const agent = await createTuiAgent(ctx);
+    const hosted = await agent.createPiInteractiveRuntime();
+    try {
+      const interactive = new InteractiveMode(hosted.runtime, { verbose: ctx.debug });
+      await interactive.init();
+      await interactive.run();
+      return 0;
+    } finally {
+      await hosted.dispose().catch(() => {
         return;
-      }
-      if (data === "\x04")
-        tui.onExit?.();
-    };
-    tui.onExit = () => {
-      unsubscribe?.();
-      tui.stopped = true;
-    };
-    tui.started = true;
-    return 0;
+      });
+    }
   } catch (error) {
     ctx.stderr(renderError(error, { json: ctx.json, debug: ctx.debug }));
     return 1;
   }
 }
-var ANSI_RESET = "\x1B[0m", ANSI_DIM_GRAY = "\x1B[90m\x1B[2m", THINKING_LEVELS2, TUI_TITLE = "AutoRAG librarian - Ctrl+C or Ctrl+D to exit";
+var THINKING_LEVELS2;
 var init_tui = __esm(() => {
   init_agent();
-  init_home();
-  init_embedding_runtime();
   init_config2();
-  init_tui_session_store();
   THINKING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 });
 
 // src/cli/commands/serve.ts
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync31 } from "node:fs";
 import { completeSimple as completeSimple2 } from "@earendil-works/pi-ai/compat";
 function classifierText(message) {
   return message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
@@ -29966,7 +29365,7 @@ function createInjectionClassifierModel(resolved) {
 async function runServe(ctx, deps = {}) {
   const flags = ctx.flags;
   const resolved = resolveConfigPath({ flags, cwd: ctx.cwd });
-  if (!existsSync32(resolved.configPath)) {
+  if (!existsSync31(resolved.configPath)) {
     ctx.stderr(renderError(new ConfigError(`Config file not found: ${resolved.configPath}. Run autorag init first.`), {
       json: ctx.json
     }));
@@ -29997,7 +29396,7 @@ async function runServe(ctx, deps = {}) {
   const injectionClassifier = p2p.injectionClassifier !== false;
   let resolvedModel;
   try {
-    resolvedModel = (deps.modelResolver ?? resolveAgentModel)(config);
+    resolvedModel = await (deps.modelResolver ?? resolveAgentModel)(config);
   } catch (error) {
     if (!injectionClassifier) {
       resolvedModel = undefined;
@@ -30349,8 +29748,8 @@ var init_p2p = __esm(() => {
 });
 
 // src/cli/commands/p2p-policy.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync26, readFileSync as readFileSync25, writeFileSync as writeFileSync24 } from "node:fs";
-import { dirname as dirname25, join as join37 } from "node:path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync23 } from "node:fs";
+import { dirname as dirname23, join as join37 } from "node:path";
 import { parse as parseToml2, stringify as stringifyToml } from "smol-toml";
 function workspacePolicyPath(cwd) {
   return join37(cwd, ".autorag", "p2p", "policy.toml");
@@ -30380,9 +29779,9 @@ function normalizeEntry(value, key) {
   throw new Error(`Invalid policy entry for ${key}: ${JSON.stringify(value)}`);
 }
 function readPolicyToml(policyPath) {
-  if (!existsSync33(policyPath))
+  if (!existsSync32(policyPath))
     return {};
-  const parsed = parseToml2(readFileSync25(policyPath, "utf8"));
+  const parsed = parseToml2(readFileSync24(policyPath, "utf8"));
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
     return {};
   let raw;
@@ -30403,22 +29802,22 @@ function readPolicyToml(policyPath) {
   return entries;
 }
 function writePolicyToml(policyPath, entries) {
-  mkdirSync26(dirname25(policyPath), { recursive: true });
+  mkdirSync25(dirname23(policyPath), { recursive: true });
   if (Object.keys(entries).length === 0) {
-    writeFileSync24(policyPath, "", { mode: 384 });
+    writeFileSync23(policyPath, "", { mode: 384 });
     return;
   }
   const data = { policy: entries };
   const toml = stringifyToml(data);
-  writeFileSync24(policyPath, toml, { mode: 384 });
+  writeFileSync23(policyPath, toml, { mode: 384 });
 }
 function getGlobalPolicy() {
   const home = resolveAutoRAGHome();
   const configPath = join37(home, "config.json");
-  if (!existsSync33(configPath))
+  if (!existsSync32(configPath))
     return {};
   try {
-    const raw = readFileSync25(configPath, "utf8");
+    const raw = readFileSync24(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.p2p && typeof parsed.p2p === "object" && !Array.isArray(parsed.p2p)) {
       const p2p = parsed.p2p;
@@ -30498,16 +29897,69 @@ var init_p2p_policy = __esm(() => {
 });
 
 // src/cli/commands/models.ts
+import { join as join38 } from "node:path";
+import { getAgentDir as getAgentDir3, ModelRuntime as ModelRuntime3 } from "@earendil-works/pi-coding-agent";
+async function listModelCatalog(options) {
+  const agentDir = options.agentDir ?? getAgentDir3();
+  const runtime = await ModelRuntime3.create({
+    authPath: join38(agentDir, "auth.json"),
+    modelsPath: join38(agentDir, "models.json"),
+    allowModelNetwork: false
+  });
+  const key = (provider, id) => `${provider}/${id}`;
+  let availableKeys = new Set;
+  try {
+    availableKeys = new Set((await runtime.getAvailable(options.provider)).map((model) => key(model.provider, model.id)));
+  } catch {}
+  const models = [...runtime.getModels(options.provider)].filter((model) => options.available !== true || availableKeys.has(key(model.provider, model.id)));
+  return models.map((model) => ({
+    provider: model.provider,
+    id: model.id,
+    name: model.name,
+    api: model.api,
+    available: availableKeys.has(key(model.provider, model.id))
+  })).sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id));
+}
 function profile(ctx) {
   const value = ctx.flags.profile;
   return typeof value === "string" ? value : undefined;
 }
+function flagString2(flags, name) {
+  const value = flags[name];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 function output(ctx, result, action) {
   ctx.stdout(ctx.json || ctx.flags.format === "json" ? JSON.stringify({ ok: true, action, ...result ?? {} }, null, 2) : `models: ${action}`);
 }
+async function runList(ctx, deps) {
+  const provider = flagString2(ctx.flags, "provider");
+  const available = ctx.flags.available === true;
+  const models = await (deps.listModels ?? listModelCatalog)({
+    ...provider !== undefined ? { provider } : {},
+    ...available ? { available: true } : {}
+  });
+  if (ctx.json || ctx.flags.format === "json") {
+    ctx.stdout(JSON.stringify({
+      ok: true,
+      action: "list",
+      ...provider !== undefined ? { provider } : {},
+      count: models.length,
+      models
+    }, null, 2));
+    return 0;
+  }
+  ctx.stdout(`models: ${models.length} model(s)`);
+  for (const model of models) {
+    ctx.stdout(`${model.provider}/${model.id}  ${model.name}${model.available ? " (auth)" : ""}`);
+  }
+  return 0;
+}
 async function runModels(ctx, deps = {}) {
   const sub = ctx.positionals[0];
   try {
+    if (sub === "list" || sub === "ls") {
+      return await runList(ctx, deps);
+    }
     if (sub === "prefetch") {
       const result = await (deps.prefetchModel ?? prefetchModel)(profile(ctx));
       output(ctx, result, "prefetch");
@@ -30526,7 +29978,7 @@ async function runModels(ctx, deps = {}) {
       output(ctx, result, "verify");
       return 0;
     }
-    throw new UsageError("Usage: autorag models prefetch|import <path>|verify [--profile <id>]");
+    throw new UsageError("Usage: autorag models list [--provider <id>] [--available] | prefetch | import <path> | verify [--profile <id>]");
   } catch (error) {
     ctx.stderr(renderError(error, { json: ctx.json || ctx.flags.format === "json", debug: ctx.debug }));
     return error instanceof UsageError ? 2 : 1;
@@ -30688,7 +30140,7 @@ var init_mirror = __esm(() => {
 });
 
 // src/cli/commands/lite-retrieve.ts
-import { existsSync as existsSync34, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync25 } from "node:fs";
 function parseIntOptional2(value) {
   if (typeof value !== "string" || value.trim() === "")
     return;
@@ -30791,10 +30243,10 @@ function renderLiteRetrieveHuman(envelope, debug) {
 }
 function hasCompletedParsedRefresh(workspacePath) {
   const markerPath = refreshReadinessPath(workspacePath);
-  if (!existsSync34(markerPath))
+  if (!existsSync33(markerPath))
     return false;
   try {
-    const marker = JSON.parse(readFileSync26(markerPath, "utf8"));
+    const marker = JSON.parse(readFileSync25(markerPath, "utf8"));
     return typeof marker === "object" && marker !== null && "version" in marker && marker.version === 1 && "completed" in marker && marker.completed === true && "parsed" in marker && marker.parsed === true;
   } catch {
     return false;
@@ -30941,12 +30393,12 @@ var init_lite_retrieve = __esm(() => {
 });
 
 // src/cli/commands/report.ts
-import { readFileSync as readFileSync27 } from "node:fs";
+import { readFileSync as readFileSync26 } from "node:fs";
 import { Value as Value3 } from "typebox/value";
 function readReportInput(input) {
   if (typeof input === "string" && input.length > 0)
-    return readFileSync27(input, "utf8");
-  return readFileSync27(0, "utf8");
+    return readFileSync26(input, "utf8");
+  return readFileSync26(0, "utf8");
 }
 function describeSchemaErrors(value) {
   const errors = Value3.Errors(emitResultsSchema, value);
@@ -31123,7 +30575,7 @@ var init_lite = __esm(() => {
 
 // src/cli/index.ts
 init_embedding_runtime();
-import { readFileSync as readFileSync28, realpathSync as realpathSync6 } from "node:fs";
+import { readFileSync as readFileSync27, realpathSync as realpathSync6 } from "node:fs";
 import { createInterface } from "node:readline";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -31303,6 +30755,19 @@ var COMMAND_USAGE = {
     "",
     "Usage: autorag tui [flags]",
     "",
+    "Runs Pi's interactive mode over the AutoRAG librarian. Pi owns the",
+    "terminal UI, provider login, model selection, session persistence,",
+    "resume/fork/compaction, settings, and extensions, so its native commands",
+    "are available in-session:",
+    "  /login, /logout       Provider credentials and OAuth",
+    "  /model                Pick the model (required before the first search",
+    "                        when no model is configured)",
+    "  /resume, /new, /tree  Resume, start, or branch sessions",
+    "  /compact, /settings   Compact context, edit settings",
+    "",
+    "AutoRAG streams progress, preliminary answers, and final results into the",
+    "same session and adds its retrieval tools.",
+    "",
     "Flags:",
     "  --fast-thinking <lvl>  Thinking level for the fast first answer",
     "  --final-thinking <lvl> Thinking level for the verified answer",
@@ -31347,18 +30812,23 @@ var COMMAND_USAGE = {
     "Peers connect via the SimpleX addresses printed by `autorag serve`."
   ]),
   models: usage([
-    "autorag models - manage the verified embedding model cache",
+    "autorag models - list configured chat models and manage the embedding cache",
     "",
-    "Usage: autorag models <prefetch|import|verify> [flags]",
+    "Usage: autorag models <list|prefetch|import|verify> [flags]",
     "",
     "Subcommands:",
-    "  prefetch        Download and verify the configured profile",
-    "  import <path>   Import an already-downloaded model file",
-    "  verify          Verify the cached model's hash",
+    "  list            List chat models from the pi runtime (built-in catalog plus",
+    "                  models.json/custom/extension providers) with provider auth status;",
+    "                  never prints credential values",
+    "  prefetch        Download and verify the configured embedding profile",
+    "  import <path>   Import an already-downloaded embedding model file",
+    "  verify          Verify the cached embedding model's hash",
     "",
     "Flags:",
-    "  --profile <id>  Embedding profile (default qwen3-embedding-0.6b)",
-    "  --format json   Emit machine-readable JSON"
+    "  --provider <id>  Restrict `list` to one provider",
+    "  --available      With `list`, show only providers with configured credentials",
+    "  --profile <id>   Embedding profile (default qwen3-embedding-0.6b)",
+    "  --format json    Emit machine-readable JSON"
   ]),
   gateway: usage([
     "autorag gateway - inspect or stop the on-demand embedding gateway",
@@ -31393,7 +30863,8 @@ var BOOLEAN_FLAGS = new Set([
   "full",
   "single-phase",
   "strict",
-  "refresh"
+  "refresh",
+  "available"
 ]);
 var VALUE_FLAGS = new Set([
   "config",
@@ -31436,6 +30907,7 @@ var VALUE_FLAGS = new Set([
   "input",
   "profile",
   "format",
+  "provider",
   "fast-thinking",
   "final-thinking"
 ]);
@@ -31496,6 +30968,7 @@ Commands:
   p2p policy list      Show effective merged sharing policy (virtual-path keys)
   p2p policy set       Set a sharing rule: <source-glob> <private|never|always|peers> [--peer fp...]
   p2p policy unset     Remove a sharing rule by key
+  models list          List chat models from the pi runtime (--provider ID --available)
   models prefetch|import|verify
                        Manage verified embedding model cache (--profile ID)
   gateway status|stop  Inspect or stop the on-demand embedding gateway (--format json)
@@ -31527,7 +31000,7 @@ Run: autorag <command> --help   for command-specific usage.
 `;
 function readPackageVersion() {
   try {
-    const manifest = JSON.parse(readFileSync28(new URL("../../package.json", import.meta.url), "utf8"));
+    const manifest = JSON.parse(readFileSync27(new URL("../../package.json", import.meta.url), "utf8"));
     return typeof manifest.version === "string" && manifest.version.length > 0 ? manifest.version : "0.0.0";
   } catch {
     return "0.0.0";