@autorag/librarian 2.5.0 → 2.5.1

package/dist/core.js

@@ -66,8 +66,6 @@ function normalizeVirtualPath(virtual) {
     return;
   if (URL_SCHEME_RE.test(v))
     return;
-  if (v.includes("#") || v.includes("?"))
-    return;
   if (v.includes("\x00"))
     return;
   if (!v.startsWith("/"))
@@ -164,8 +162,21 @@ function saveMirrorIndex(root, index) {
 function isParsedMirrorIndex(value) {
   if (!isRecord(value) || value.version !== 1 || !isRecord(value.entries))
     return false;
+  if (value.skipped !== undefined && !isParsedMirrorSkipRecord(value.skipped))
+    return false;
   return Object.entries(value.entries).every(([key, entry]) => isParsedMirrorEntry(entry) && key === entry.virtualPath);
 }
+function isParsedMirrorSkipRecord(value) {
+  if (!isRecord(value))
+    return false;
+  return Object.entries(value).every(([key, entry]) => isParsedMirrorSkipEntry(entry) && key === entry.virtualPath);
+}
+function isParsedMirrorSkipEntry(value) {
+  return isRecord(value) && typeof value.virtualPath === "string" && typeof value.sourcePath === "string" && isParsedMirrorSkipReason(value.reason) && typeof value.sourceMtimeNs === "number" && typeof value.sourceSizeBytes === "number" && typeof value.updatedAt === "string";
+}
+function isParsedMirrorSkipReason(value) {
+  return value === "duplicate-excluded" || value === "parser-skipped" || value === "parser-failed";
+}
 function isParsedMirrorEntry(value) {
   return isRecord(value) && typeof value.virtualPath === "string" && typeof value.sourcePath === "string" && typeof value.outputPath === "string" && typeof value.parserName === "string" && typeof value.sourceMtimeNs === "number" && typeof value.sourceSizeBytes === "number" && typeof value.updatedAt === "string";
 }
@@ -2531,6 +2542,11 @@ function rewriteEmbedderConfig(workspacePath, embedder, chunkerConfig = {}) {
   parsed.chunker = chunker;
   const chunkerOptions = typeof chunker.options === "object" && chunker.options !== null && !Array.isArray(chunker.options) ? chunker.options : {};
   chunker.options = chunkerOptions;
+  if (embedder.id?.startsWith("native:")) {
+    delete embedderSection.base_url;
+    delete embedderSection.query_prefix;
+    delete embedderSection.passage_prefix;
+  }
   if (embedder.id !== undefined)
     embedderSection.id = embedder.id;
   if (embedder.baseUrl !== undefined)
@@ -2555,8 +2571,13 @@ function rewriteEmbedderConfig(workspacePath, embedder, chunkerConfig = {}) {
   writeFileSync3(configPath, stringify(parsed));
   return true;
 }
-var EMBEDDING_IDENTITY_FILE = "autorag-embedding-identity.json", MINSYNC_CONFIG_DIR = ".minsync", MINSYNC_CONFIG_FILE = "config.toml";
-var init_embedder_config = () => {};
+var EMBEDDING_IDENTITY_FILE = "autorag-embedding-identity.json", DEFAULT_MINSYNC_EMBEDDER_ID = "native:Qwen/Qwen3-Embedding-0.6B", DEFAULT_MINSYNC_EMBEDDER_DIMENSION = 1024, DEFAULT_MINSYNC_EMBEDDER_CONFIG, MINSYNC_CONFIG_DIR = ".minsync", MINSYNC_CONFIG_FILE = "config.toml";
+var init_embedder_config = __esm(() => {
+  DEFAULT_MINSYNC_EMBEDDER_CONFIG = {
+    id: DEFAULT_MINSYNC_EMBEDDER_ID,
+    dimension: DEFAULT_MINSYNC_EMBEDDER_DIMENSION
+  };
+});
 
 // src/minsync/local-embedder.ts
 import { spawn as spawn4 } from "node:child_process";
@@ -2697,9 +2718,32 @@ class MinSyncClient {
   }
   async effectiveEmbedder() {
     const configured = this.embedder;
-    const useRuntime = this.runtime !== undefined && (configured === undefined || configured.profile !== undefined && configured.baseUrl === undefined);
-    if (!useRuntime)
+    const isExplicitNative = configured?.id?.startsWith("native:");
+    const isExplicitRemoteOrTei = configured?.baseUrl !== undefined || configured?.id !== undefined && !isExplicitNative && configured.profile === undefined;
+    const useRuntime = this.runtime !== undefined && !isExplicitNative && !isExplicitRemoteOrTei && (configured?.profile !== undefined || configured === undefined && this.runtime !== undefined);
+    if (!useRuntime) {
+      if (configured?.baseUrl === undefined && (configured === undefined || isExplicitNative || configured.id === undefined)) {
+        const id = configured?.id ?? DEFAULT_MINSYNC_EMBEDDER_ID;
+        const dimension = configured?.dimension ?? DEFAULT_MINSYNC_EMBEDDER_DIMENSION;
+        return {
+          config: {
+            ...configured,
+            id,
+            dimension
+          },
+          identity: {
+            provider: "native",
+            model: id.startsWith("native:") ? id.slice("native:".length) : id,
+            artifactRevision: "default",
+            dimension,
+            queryPrefix: configured?.queryPrefix ?? "",
+            passagePrefix: configured?.passagePrefix ?? "",
+            runtimeBuild: "minsync-native"
+          }
+        };
+      }
       return { config: configured ?? {} };
+    }
     try {
       const ensured = await this.runtime?.ensureRuntime({ profileId: configured?.profile, cachedOnly: true });
       if (!ensured)
@@ -2710,7 +2754,11 @@ class MinSyncClient {
           baseUrl: ensured.baseUrl,
           dimension: ensured.profile.dimension,
           queryPrefix: ensured.profile.queryPrefix,
-          passagePrefix: ensured.profile.passagePrefix
+          passagePrefix: ensured.profile.passagePrefix,
+          ...configured?.batchSize !== undefined ? { batchSize: configured.batchSize } : {},
+          ...configured?.maxRetries !== undefined ? { maxRetries: configured.maxRetries } : {},
+          ...configured?.maxConcurrent !== undefined ? { maxConcurrent: configured.maxConcurrent } : {},
+          ...configured?.timeoutMs !== undefined ? { timeoutMs: configured.timeoutMs } : {}
         },
         identity: {
           provider: ensured.identity.provider,
@@ -2790,8 +2838,8 @@ class MinSyncClient {
     const cursorPath = join9(this.workspacePath, ".minsync", "cursor.json");
     if (!initialized) {
       const initArgs = ["init", "--format", "json"];
-      if (embedder.id) {
-        initArgs.push("--embedder", embedder.id);
+      if (this.embedder?.id) {
+        initArgs.push("--embedder", this.embedder.id);
       }
       const init = await this.spawn(initArgs, spawnOpts);
       if (!init.ok || !existsSync7(minSyncConfigPath(this.workspacePath))) {
@@ -2820,13 +2868,28 @@ class MinSyncClient {
         ok: false,
         synced: 0,
         workspacePath: this.workspacePath,
-        reason: "check-failed"
+        reason: "check-failed",
+        diagnostic: {
+          code: "sync-failed",
+          message: check.stderr ? check.stderr.trim() : "MinSync check failed.",
+          retryable: true
+        }
       };
     }
     const checkFailure = readCheckFailure(check.stdout);
     if (checkFailure) {
       restoreConfig();
-      return { ok: false, synced: 0, workspacePath: this.workspacePath, reason: checkFailure };
+      return {
+        ok: false,
+        synced: 0,
+        workspacePath: this.workspacePath,
+        reason: checkFailure,
+        diagnostic: {
+          code: checkFailure.includes("embedder") ? "embedder-unavailable" : "sync-failed",
+          message: checkFailure,
+          retryable: true
+        }
+      };
     }
     const chunkSizeChanged = this.maxChunkSize !== undefined && configuredChunkSize !== this.maxChunkSize;
     const dimensionChanged = embedder.dimension !== undefined && configuredDimension !== embedder.dimension;
@@ -2840,7 +2903,12 @@ class MinSyncClient {
         ok: false,
         synced: 0,
         workspacePath: this.workspacePath,
-        reason: "sync-failed"
+        reason: "sync-failed",
+        diagnostic: {
+          code: "sync-failed",
+          message: result.stderr ? result.stderr.trim() : "MinSync sync failed.",
+          retryable: true
+        }
       };
     }
     if (!existsSync7(cursorPath)) {
@@ -2871,7 +2939,8 @@ class MinSyncClient {
       const migration = configuredDimension === 768 && effective.config.dimension !== 768 ? ` ${MINSYNC_OLLAMA_MIGRATION_MESSAGE}` : "";
       throw new MinSyncQueryError(null, `configured embedder dimension ${effective.config.dimension} does not match indexed dimension ${configuredDimension}; reindex required.${migration}`);
     }
-    if (effective.identity !== undefined && this.identityMismatch(effective.identity)) {
+    const cursorPath = join9(this.workspacePath, ".minsync", "cursor.json");
+    if (existsSync7(cursorPath) && effective.identity !== undefined && this.identityMismatch(effective.identity)) {
       throw new MinSyncQueryError(null, "embedding identity does not match the indexed workspace; full reindex required");
     }
     const shouldRewriteConfig = this.embedder !== undefined || effective.identity !== undefined;
@@ -3196,7 +3265,7 @@ function isGitHubAsset(value) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
-var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.2", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
+var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.5", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
 var init_installer2 = __esm(() => {
   init_process();
   SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/;
@@ -3624,7 +3693,7 @@ function listen(server, port, host) {
 function close(server) {
   return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
 }
-var GatewayError, DEFAULT_MAX_INPUTS = 128, DEFAULT_MAX_CHARACTERS = 1e5, DEFAULT_TIMEOUT_MS3 = 30000, MAX_BODY_BYTES = 2000000;
+var GatewayError, MINSYNC_DEFAULT_BATCH_SIZE = 64, MINSYNC_DEFAULT_MAX_CHUNK_SIZE = 4096, DEFAULT_MAX_INPUTS = 128, DEFAULT_MAX_CHARACTERS, DEFAULT_TIMEOUT_MS3 = 30000, MAX_BODY_BYTES = 2000000;
 var init_gateway = __esm(() => {
   GatewayError = class GatewayError extends Error {
     code;
@@ -3636,6 +3705,7 @@ var init_gateway = __esm(() => {
       this.status = status;
     }
   };
+  DEFAULT_MAX_CHARACTERS = MINSYNC_DEFAULT_BATCH_SIZE * MINSYNC_DEFAULT_MAX_CHUNK_SIZE;
 });
 
 // src/embedding-runtime/manifest.ts
@@ -4187,6 +4257,22 @@ function identity(profile) {
     artifactSha256: profile.artifactSha256
   };
 }
+function incompatibleGateway(message) {
+  return { ok: false, code: "incompatible", message, retryable: false };
+}
+function normalizeGatewayHealth(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return incompatibleGateway("Gateway health response was not a JSON object.");
+  }
+  const { status, profileId, dimension, runtimeBuild } = payload;
+  if (status !== "ok") {
+    return incompatibleGateway('Gateway health response did not report status "ok".');
+  }
+  if (typeof profileId !== "string" || typeof dimension !== "number" || typeof runtimeBuild !== "string") {
+    return incompatibleGateway("Gateway health response was missing profile identity fields.");
+  }
+  return { ok: true, profileId, dimension, runtimeBuild };
+}
 function createEmbeddingRuntime(options = {}) {
   const root = options.cacheRoot ?? resolveAutoRAGHome();
   const cache = options.cache ?? {
@@ -4208,8 +4294,22 @@ function createEmbeddingRuntime(options = {}) {
     const runtimePath = await cache.downloadAsset(runtimeAsset(options.platform, options.backend ?? profile.backend), cacheOptions);
     return { modelPath, runtimePath };
   }
+  let ensureInFlight;
   async function ensureRuntime(input = {}) {
     const profile = profileOf(input.profileId);
+    const pending = ensureInFlight;
+    if (pending !== undefined && pending.profileId === profile.profileId)
+      return pending.promise;
+    const promise = ensureRuntimeOnce(profile, input);
+    ensureInFlight = { profileId: profile.profileId, promise };
+    try {
+      return await promise;
+    } finally {
+      if (ensureInFlight?.promise === promise)
+        ensureInFlight = undefined;
+    }
+  }
+  async function ensureRuntimeOnce(profile, input) {
     stoppedByService = false;
     const selectedSupervisor = input.supervisor ?? options.supervisor;
     if (selectedSupervisor)
@@ -4286,7 +4386,7 @@ function createEmbeddingRuntime(options = {}) {
       const response = await (options.fetch ?? fetch)(`${gateway.url}/healthz`);
       if (!response.ok)
         throw new Error(`Gateway health returned HTTP ${response.status}.`);
-      const health = await response.json();
+      const health = normalizeGatewayHealth(await response.json());
       return { ...base, profileId: activeProfile?.profileId, baseUrl: gateway.url, health };
     } catch {
       return {
@@ -4373,7 +4473,9 @@ function syncMinSyncWorkspace(root, options = {}) {
   const workspacePath = options.workspacePath ?? minSyncWorkspaceRoot(root);
   const filesRoot = join14(workspacePath, "files");
   const index = loadMirrorIndex(root);
-  const entries = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath)).filter((entry) => normalizeVirtualPath(entry.virtualPath) === entry.virtualPath && existsSync10(entry.outputPath)).map((entry) => {
+  const candidates = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath));
+  const excluded = candidates.filter((entry) => normalizeVirtualPath(entry.virtualPath) !== entry.virtualPath || !existsSync10(entry.outputPath)).map((entry) => entry.virtualPath);
+  const entries = candidates.filter((entry) => normalizeVirtualPath(entry.virtualPath) === entry.virtualPath && existsSync10(entry.outputPath)).map((entry) => {
     const minSyncPath = minSyncDocumentPath(workspacePath, entry.virtualPath);
     return {
       virtualPath: entry.virtualPath,
@@ -4404,7 +4506,7 @@ function syncMinSyncWorkspace(root, options = {}) {
   }
   removeUnexpectedStagedFiles(filesRoot, desiredPaths);
   saveStagingState(workspacePath, { version: 1, entries: currentState });
-  return { workspacePath, entries };
+  return { workspacePath, entries, excluded };
 }
 function stagingStatePath(workspacePath) {
   return join14(dirname6(workspacePath), `.${basename6(workspacePath)}-autorag-staging.json`);
@@ -4531,6 +4633,16 @@ function lookupInPath(env) {
   }
   return;
 }
+function withWorkspaceLock(workspacePath, run) {
+  const previous = workspaceOperationTails.get(workspacePath) ?? Promise.resolve();
+  const result = previous.then(run, run);
+  workspaceOperationTails.set(workspacePath, result.then(() => {
+    return;
+  }, () => {
+    return;
+  }));
+  return result;
+}
 
 class MinSyncVectorMethod {
   root;
@@ -4552,7 +4664,7 @@ class MinSyncVectorMethod {
     this.embedder = options.embedder;
     this.maxChunkSize = options.maxChunkSize;
     this.mode = options.mode ?? "vector";
-    this.runtime = options.runtime ?? (options.binaryPath === undefined && options.autoInstall !== false ? { ensureRuntime } : undefined);
+    this.runtime = options.runtime ?? (this.embedder?.profile !== undefined && options.binaryPath === undefined && options.autoInstall !== false ? { ensureRuntime } : undefined);
   }
   describe() {
     return {
@@ -4569,10 +4681,14 @@ class MinSyncVectorMethod {
     };
   }
   async sync(force = false) {
-    syncMinSyncWorkspace(this.root, { workspacePath: this.workspacePath });
+    return withWorkspaceLock(this.workspacePath, () => this.syncUnlocked(force));
+  }
+  async syncUnlocked(force) {
+    const staging = syncMinSyncWorkspace(this.root, { workspacePath: this.workspacePath });
+    const withExcluded = (result) => staging.excluded.length === 0 ? result : { ...result, stagingExcluded: staging.excluded };
     const binaryResult = await this.resolveBinary();
     if (binaryResult === undefined) {
-      return degrade(this.workspacePath, "missing-binary");
+      return withExcluded(degrade(this.workspacePath, "missing-binary"));
     }
     if (typeof binaryResult === "string") {
       const client = new MinSyncClient({
@@ -4582,9 +4698,9 @@ class MinSyncVectorMethod {
         maxChunkSize: this.maxChunkSize,
         runtime: this.runtime
       });
-      return client.sync(force);
+      return withExcluded(await client.sync(force));
     }
-    return binaryResult;
+    return withExcluded(binaryResult);
   }
   isBinaryMissing() {
     if (this.binaryPath !== undefined)
@@ -4603,6 +4719,9 @@ class MinSyncVectorMethod {
     return existsSync11(join15(this.workspacePath, ".minsync", "cursor.json"));
   }
   async retrieve(query, options) {
+    return withWorkspaceLock(this.workspacePath, () => this.retrieveUnlocked(query, options));
+  }
+  async retrieveUnlocked(query, options) {
     const topK = options.topK ?? 20;
     const queryK = options.scope ? Math.min(Math.max(topK * 5, topK + 20), 100) : topK;
     const byPath = buildMinSyncPathMap(this.root, this.workspacePath);
@@ -4670,7 +4789,7 @@ class MinSyncVectorMethod {
     return;
   }
 }
-var MinSyncHybridMethod;
+var workspaceOperationTails, MinSyncHybridMethod;
 var init_method = __esm(() => {
   init_embedding_runtime();
   init_scope();
@@ -4678,6 +4797,7 @@ var init_method = __esm(() => {
   init_installer2();
   init_paths2();
   init_workspace();
+  workspaceOperationTails = new Map;
   MinSyncHybridMethod = class MinSyncHybridMethod extends MinSyncVectorMethod {
     constructor(options) {
       super({ ...options, mode: "hybrid" });
@@ -5841,19 +5961,34 @@ async function syncParsedMirrors(options) {
   const current = await listCurrentFiles(options.searchPaths, supportedExtensions);
   const previous = loadMirrorIndex(options.root);
   const nextEntries = {};
+  const nextSkipped = {};
   const handledPrevious = new Set;
   let written = 0;
   let skipped = 0;
   let deleted = 0;
   let sinceCheckpoint = 0;
   const diagnostics = [];
+  const recordSkip = (entry, reason) => {
+    nextSkipped[entry.virtualPath] = {
+      virtualPath: entry.virtualPath,
+      sourcePath: entry.sourcePath,
+      reason,
+      sourceMtimeNs: entry.mtimeNs,
+      sourceSizeBytes: entry.sizeBytes,
+      updatedAt: new Date().toISOString()
+    };
+  };
   const checkpoint = () => {
     const merged = { ...previous.entries, ...nextEntries };
+    const mergedSkipped = { ...previous.skipped, ...nextSkipped };
     for (const virtualPath of handledPrevious) {
-      if (!(virtualPath in nextEntries))
-        delete merged[virtualPath];
+      if (virtualPath in nextEntries) {
+        delete mergedSkipped[virtualPath];
+        continue;
+      }
+      delete merged[virtualPath];
     }
-    saveMirrorIndex(options.root, { version: 1, entries: merged });
+    saveMirrorIndex(options.root, { version: 1, entries: merged, skipped: mergedSkipped });
     sinceCheckpoint = 0;
   };
   for (const entry of current) {
@@ -5861,6 +5996,7 @@ async function syncParsedMirrors(options) {
       deleted += removePrevious(options.root, previous, entry.virtualPath);
       handledPrevious.add(entry.virtualPath);
       skipped += 1;
+      recordSkip(entry, "duplicate-excluded");
       diagnostics.push({
         code: "duplicate-excluded",
         severity: "info",
@@ -5874,12 +6010,14 @@ async function syncParsedMirrors(options) {
       deleted += removePrevious(options.root, previous, entry.virtualPath);
       handledPrevious.add(entry.virtualPath);
       skipped += 1;
+      recordSkip(entry, "parser-skipped");
       continue;
     }
     if (entry.sizeBytes > maxSourceBytes) {
       deleted += removePrevious(options.root, previous, entry.virtualPath);
       handledPrevious.add(entry.virtualPath);
       skipped += 1;
+      recordSkip(entry, "parser-skipped");
       diagnostics.push({
         code: "parser-skipped",
         severity: "warning",
@@ -5905,6 +6043,7 @@ async function syncParsedMirrors(options) {
         deleted += removePrevious(options.root, previous, entry.virtualPath);
         handledPrevious.add(entry.virtualPath);
         skipped += 1;
+        recordSkip(entry, "parser-failed");
         diagnostics.push({
           code: parserFailureCode(parser, error),
           severity: "warning",
@@ -5955,7 +6094,7 @@ async function syncParsedMirrors(options) {
       source: virtualPath
     });
   }
-  const index = { version: 1, entries: nextEntries };
+  const index = { version: 1, entries: nextEntries, skipped: nextSkipped };
   saveMirrorIndex(options.root, index);
   return {
     scanned: current.length,
@@ -5978,16 +6117,20 @@ async function detectMirrorStaleness(options) {
     if (!registry.getForVirtualPath(entry.virtualPath))
       continue;
     const prev = previous.entries[entry.virtualPath];
-    if (!prev || prev.sourceMtimeNs !== entry.mtimeNs || prev.sourceSizeBytes !== entry.sizeBytes) {
-      const reason = prev === undefined ? "source-added" : prev.sourceMtimeNs !== entry.mtimeNs && prev.sourceSizeBytes !== entry.sizeBytes ? "mtime-and-size-changed" : prev.sourceMtimeNs !== entry.mtimeNs ? "mtime-changed" : "size-changed";
-      diagnostics.push({
-        code: "stale-index",
-        severity: "warning",
-        message: `Source ${entry.virtualPath} is ${reason.replaceAll("-", " ")} since the last refresh; indexes may be stale.`,
-        source: entry.virtualPath,
-        reason
-      });
-    }
+    if (prev !== undefined && prev.sourceMtimeNs === entry.mtimeNs && prev.sourceSizeBytes === entry.sizeBytes)
+      continue;
+    const prevSkip = previous.skipped?.[entry.virtualPath];
+    if (prevSkip !== undefined && prevSkip.sourceMtimeNs === entry.mtimeNs && prevSkip.sourceSizeBytes === entry.sizeBytes)
+      continue;
+    const known = prev ?? prevSkip;
+    const reason = known === undefined ? "source-added" : known.sourceMtimeNs !== entry.mtimeNs && known.sourceSizeBytes !== entry.sizeBytes ? "mtime-and-size-changed" : known.sourceMtimeNs !== entry.mtimeNs ? "mtime-changed" : "size-changed";
+    diagnostics.push({
+      code: "stale-index",
+      severity: "warning",
+      message: `Source ${entry.virtualPath} is ${reason.replaceAll("-", " ")} since the last refresh; indexes may be stale.`,
+      source: entry.virtualPath,
+      reason
+    });
   }
   return diagnostics;
 }
@@ -6022,6 +6165,8 @@ async function collectFiles(sourceRoot, directory, entries, supportedExtensions)
   for await (const entry of dir) {
     if (SKIP_DIR_NAMES.has(entry.name))
       continue;
+    if (PRODUCT_ARTIFACT_FILE_NAMES.has(entry.name))
+      continue;
     const sourcePath = resolve9(directory, entry.name);
     if (entry.isDirectory()) {
       await collectFiles(sourceRoot, sourcePath, entries, supportedExtensions);
@@ -6063,7 +6208,7 @@ function removeFile(path) {
   if (existsSync12(path))
     rmSync3(path, { force: true });
 }
-var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, SKIP_DIR_NAMES;
+var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, PRODUCT_ARTIFACT_FILE_NAMES, SKIP_DIR_NAMES;
 var init_sync = __esm(() => {
   init_source_paths();
   init_defaults();
@@ -6072,6 +6217,7 @@ var init_sync = __esm(() => {
   init_index_store();
   init_paths();
   DEFAULT_MAX_SOURCE_BYTES = 50 * 1024 * 1024;
+  PRODUCT_ARTIFACT_FILE_NAMES = new Set([".jikji_agent_map.md"]);
   SKIP_DIR_NAMES = new Set([
     ".autorag",
     ".git",
@@ -9257,7 +9403,7 @@ var init_watch_refresh = __esm(() => {
 
 // src/agent/agent.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { watch as fsWatch, mkdirSync as mkdirSync11, realpathSync as realpathSync4, statSync, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync16, watch as fsWatch, mkdirSync as mkdirSync11, realpathSync as realpathSync4, statSync, writeFileSync as writeFileSync10 } from "node:fs";
 import { dirname as dirname12, join as join21, resolve as resolve11 } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
 import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
@@ -10140,14 +10286,22 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         writeFileSync10(refreshReadinessPath(this.workspaceProjectRoot), `{"version":1,"completed":true,"parsed":true}
 `);
       }
+      const minsyncDiagnostics = minSyncRefreshDiagnostics(minsync);
       const publicMinsync = minsync ? {
         ok: minsync.ok,
         synced: minsync.synced,
-        ...minsync.reason !== undefined ? { reason: minsync.reason } : {}
+        ...minsync.reason !== undefined ? { reason: sanitizeDiagnosticMessage(minsync.reason) } : {},
+        ...minsyncDiagnostics.length > 0 ? { diagnostics: minsyncDiagnostics } : {},
+        ...minsync.stagingExcluded !== undefined && minsync.stagingExcluded.length > 0 ? { stagingExcludedCount: minsync.stagingExcluded.length } : {}
       } : undefined;
       return {
         ...summary,
-        diagnostics: [...this.startupDiagnostics, ...summary.diagnostics],
+        diagnostics: [
+          ...this.startupDiagnostics,
+          ...summary.diagnostics,
+          ...minsyncDiagnostics,
+          ...stagingExcludedDiagnostics(minsync?.stagingExcluded)
+        ],
         minsync: publicMinsync,
         datasources
       };
@@ -10186,6 +10340,11 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
     for (const result of this.refreshState.datasources) {
       diagnostics.push(...mapDatasourceDiagnostics(result.diagnostics));
     }
+    for (const diag of minSyncRefreshDiagnostics(this.refreshState.minsync)) {
+      if (!diagnostics.some((d) => d.code === diag.code && d.source === diag.source)) {
+        diagnostics.push(diag);
+      }
+    }
     if (this.refreshState.watchLimited) {
       diagnostics.push({
         code: "watch-limited",
@@ -10203,13 +10362,14 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
       });
     }
     const state = this.refreshState.inFlight ? "indexing" : this.refreshState.lastOutcome === "never" ? "idle" : this.refreshState.lastOutcome;
+    const parsedMirrorReady = this.refreshState.lastOutcome === "success" || existsSync16(refreshReadinessPath(this.workspaceProjectRoot));
     return {
       state,
       inFlight: this.refreshState.inFlight,
       lastStartedAt: this.refreshState.lastStartedAt,
       lastFinishedAt: this.refreshState.lastFinishedAt,
       counts: this.refreshState.counts,
-      stale: this.refreshState.lastOutcome === "never" || staleDiagnostics.length > 0,
+      stale: !parsedMirrorReady || staleDiagnostics.length > 0,
       diagnostics,
       components: this.refreshComponentStatus(),
       lastError: this.refreshState.lastError
@@ -10659,6 +10819,14 @@ function lastAssistantText(messages) {
   }
   return;
 }
+function stagingExcludedDiagnostics(excluded) {
+  return (excluded ?? []).map((source) => ({
+    code: "minsync-staging-excluded",
+    severity: "warning",
+    message: "Excluded from the MinSync index: this file name cannot be represented as a canonical source id.",
+    source
+  }));
+}
 function toSearchDiagnostic(diagnostic) {
   return {
     code: diagnostic.code,
@@ -10667,6 +10835,38 @@ function toSearchDiagnostic(diagnostic) {
     source: diagnostic.source
   };
 }
+function sanitizeDiagnosticMessage(raw) {
+  let out = raw.split(/\n\s+at\s/)[0] ?? raw;
+  out = out.replace(/(?:^|[^A-Za-z0-9])(\/(?:[^/\s]+\/)+[^/\s]+)/g, " <path>");
+  out = out.replace(/[A-Za-z]:\\[^\s]+/g, "<path>");
+  return out.replace(/\s{2,}/g, " ").trim();
+}
+function minSyncRefreshDiagnostics(minsync) {
+  if (!minsync)
+    return [];
+  if (minsync.diagnostic)
+    return [toMinSyncDiagnostic(minsync.diagnostic, minsync.ok)];
+  if (!minsync.ok && minsync.reason)
+    return [toMinSyncReasonDiagnostic(minsync.reason)];
+  return [];
+}
+function toMinSyncDiagnostic(diag, ok) {
+  const code = diag.code === "embedder-unavailable" ? "embedder-unavailable" : diag.code === "embedding-identity-mismatch" ? "embedding-identity-mismatch" : "minsync-sync-failed";
+  return {
+    code,
+    severity: ok ? "info" : "error",
+    message: sanitizeDiagnosticMessage(diag.message),
+    source: "minsync"
+  };
+}
+function toMinSyncReasonDiagnostic(reason) {
+  return {
+    code: reason === "missing-binary" ? "minsync-unavailable" : "minsync-sync-failed",
+    severity: reason === "missing-binary" ? "warning" : "error",
+    message: reason === "missing-binary" ? "MinSync binary is not available and auto-install was skipped." : `MinSync sync failed: ${sanitizeDiagnosticMessage(reason)}`,
+    source: "minsync"
+  };
+}
 function pinSearchRoot(searchPath) {
   const resolvedPath = resolve11(searchPath);
   let canonicalPath;
@@ -10899,7 +11099,7 @@ ${this.description}`
 
 // src/datasource/skills/clawgallery/client.ts
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 
 class ClawGalleryClient {
   options;
@@ -10907,7 +11107,7 @@ class ClawGalleryClient {
     this.options = options;
   }
   async bootstrap(signal) {
-    if (this.options.path !== undefined && !existsSync16(this.options.path)) {
+    if (this.options.path !== undefined && !existsSync17(this.options.path)) {
       return {
         ok: false,
         reason: "nonzero-exit",
@@ -11864,7 +12064,7 @@ function sanitizeIdSegment(value) {
 var init_connector = () => {};
 
 // src/datasource/chunk-store.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname14, join as join23 } from "node:path";
 function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
   return join23(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
@@ -11904,7 +12104,7 @@ class DatasourceChunkStore {
     if (this.storePath === undefined)
       return false;
     try {
-      if (!existsSync17(this.storePath))
+      if (!existsSync18(this.storePath))
         return false;
       const parsed = JSON.parse(readFileSync14(this.storePath, "utf8"));
       if (parsed.version !== STORE_VERSION || !Array.isArray(parsed.chunks))
@@ -12404,7 +12604,7 @@ var init_cloud_drive = __esm(() => {
 });
 
 // src/datasource/skills/discrawl/types.ts
-var ENGLISH_ONLY_EMBEDDING_MODELS, DEFAULT_DISCRAWL_EMBEDDING_MODEL = "embeddinggemma", DEFAULT_DISCRAWL_BINARY = "discrawl", DEFAULT_DISCRAWL_TIMEOUT_MS = 30000, DEFAULT_DISCRAWL_MAX_BUFFER_BYTES = 1048576, DEFAULT_DISCRAWL_SOURCE = "wiretap", DEFAULT_DISCRAWL_MODE = "hybrid";
+var ENGLISH_ONLY_EMBEDDING_MODELS, DEFAULT_DISCRAWL_EMBEDDING_MODEL = "embeddinggemma", DEFAULT_DISCRAWL_BINARY = "discrawl", DEFAULT_DISCRAWL_TIMEOUT_MS = 30000, DEFAULT_DISCRAWL_MAX_BUFFER_BYTES = 1048576, DEFAULT_DISCRAWL_MODE = "hybrid";
 var init_types3 = __esm(() => {
   ENGLISH_ONLY_EMBEDDING_MODELS = new Set([
     "nomic-embed-text",
@@ -12493,12 +12693,7 @@ class DiscrawlClient {
     return data === undefined ? toFailure(result, "invalid-shape") : ok2(data, result);
   }
   async sync(signal) {
-    const source = this.options.source ?? DEFAULT_DISCRAWL_SOURCE;
-    const args = source === "wiretap" ? ["wiretap"] : ["sync", "--source", source];
-    if (source !== "wiretap" && this.options.guildId !== undefined) {
-      args.push("--guild", this.options.guildId);
-    }
-    const result = await this.runJson(args, signal);
+    const result = await this.runJson(["wiretap"], signal);
     if (!result.ok)
       return toFailure(result);
     const parsed = parseJsonObject(result.stdout);
@@ -12681,7 +12876,7 @@ function controlledEnv2(configuredEnv) {
   return env;
 }
 function isAllowedDiscrawlEnvKey(key) {
-  return SAFE_INHERITED_ENV_KEYS.has(key) || ALLOWED_DISCORD_ENV_KEYS.has(key) || key.startsWith(SAFE_DISCRAWL_ENV_PREFIX);
+  return SAFE_INHERITED_ENV_KEYS.has(key) || key.startsWith(SAFE_DISCRAWL_ENV_PREFIX);
 }
 function findUserTokenKey(env) {
   for (const [key, value] of Object.entries(env)) {
@@ -12920,7 +13115,7 @@ function sanitizeDiagnosticText(value) {
 function ok2(data, result) {
   return { ok: true, data, stdout: result.stdout, stderr: result.stderr, code: result.code ?? 0 };
 }
-var USER_TOKEN_KEYS, SAFE_INHERITED_ENV_KEYS, SAFE_DISCRAWL_ENV_PREFIX = "DISCRAWL_", ALLOWED_DISCORD_ENV_KEYS;
+var USER_TOKEN_KEYS, SAFE_INHERITED_ENV_KEYS, SAFE_DISCRAWL_ENV_PREFIX = "DISCRAWL_";
 var init_client4 = __esm(() => {
   init_portable_spawn();
   init_types3();
@@ -12931,7 +13126,6 @@ var init_client4 = __esm(() => {
     "discord_account_token"
   ]);
   SAFE_INHERITED_ENV_KEYS = new Set(["HOME", "LANG", "LC_ALL", "PATH", "TMPDIR", "TMP", "TEMP"]);
-  ALLOWED_DISCORD_ENV_KEYS = new Set(["DISCORD_BOT_TOKEN"]);
 });
 
 // src/datasource/skills/discrawl/paths.ts
@@ -17069,7 +17263,7 @@ var init_factory = __esm(() => {
 
 // src/cli/config.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync18, mkdirSync as mkdirSync17, readFileSync as readFileSync16, renameSync as renameSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync17, readFileSync as readFileSync16, renameSync as renameSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync15 } from "node:fs";
 import { basename as basename12, dirname as dirname17, isAbsolute as isAbsolute7, join as join26, resolve as resolve13 } from "node:path";
 import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
 function resolveConfigPath(input) {
@@ -17093,7 +17287,7 @@ function resolveConfigPath(input) {
 function readConfigFile(configPath, explicit) {
   let exists;
   try {
-    exists = existsSync18(configPath);
+    exists = existsSync19(configPath);
   } catch {
     exists = false;
   }
@@ -17153,7 +17347,7 @@ function replaceFileAtomically(path, contents, assertCommitAllowed) {
   }
 }
 function migrateLegacyConfig(configPath, legacyPath) {
-  if (existsSync18(configPath) || !existsSync18(legacyPath))
+  if (existsSync19(configPath) || !existsSync19(legacyPath))
     return;
   const legacy = readConfigFile(legacyPath, true);
   const legacyBytes = readFileSync16(legacyPath);
@@ -17983,7 +18177,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
 `;
   const lock = acquireConfigWriteLock(path);
   try {
-    if (!opts.force && existsSync18(path)) {
+    if (!opts.force && existsSync19(path)) {
       throw new ConfigError(`Config file already exists: ${path}`);
     }
     if (opts.force || opts.atomicCreate)