opencode-rag-plugin 1.19.4 → 1.19.8

package/dist/chunker/base.js

@@ -2,7 +2,7 @@
  * @fileoverview Abstract base class for tree-sitter based language chunkers.
  */
 import { Parser } from "web-tree-sitter";
-import { loadLanguage, loadLanguageFromPath, walkTree } from "./grammar.js";
+import { loadLanguage, loadLanguageFromPath, walkTree, buildByteOffsetMap } from "./grammar.js";
 import { uuid } from "./uuid.js";
 /** Module-level parser pool shared across all TreeSitterChunker instances. */
 const parserPool = new Map();
@@ -45,8 +45,15 @@ export class TreeSitterChunker {
                 if (!tree) {
                     return [];
                 }
-                const nodes = walkTree(tree.rootNode, types, content);
-                tree.delete();
+                // tree-sitter ranges are UTF-8 byte offsets; translate for slicing
+                const offsetMap = buildByteOffsetMap(content);
+                let nodes;
+                try {
+                    nodes = walkTree(tree.rootNode, types, content, 10, 0, offsetMap);
+                }
+                finally {
+                    tree.delete();
+                }
                 return nodes.map((node) => ({
                     id: uuid(),
                     content: node.text,
@@ -108,8 +115,15 @@ export class TreeSitterChunker {
         if (!tree) {
             return [];
         }
-        const nodes = walkTree(tree.rootNode, this.nodeTypes, content);
-        tree.delete();
+        // tree-sitter ranges are UTF-8 byte offsets; translate for slicing
+        const offsetMap = buildByteOffsetMap(content);
+        let nodes;
+        try {
+            nodes = walkTree(tree.rootNode, this.nodeTypes, content, 10, 0, offsetMap);
+        }
+        finally {
+            tree.delete();
+        }
         return nodes.map((node) => ({
             id: uuid(),
             content: node.text,

package/dist/chunker/factory.js

@@ -174,14 +174,26 @@ function splitOversized(chunks, filePath) {
     }
     return result;
 }
-/** Apply config overrides to a chunker before it's used. */
-function applyChunkerConfig(chunker, _filePath, options) {
-    if (options?.maxSvgSizeBytes && chunker instanceof TreeSitterChunker) {
-        const ext = _filePath.toLowerCase();
-        if (ext.endsWith(".svg") || ext.endsWith(".xml") || ext.endsWith(".csproj")) {
-            chunker.maxContentBytes = options.maxSvgSizeBytes;
-        }
-    }
+/**
+ * Wrap a chunker with a per-file byte limit.
+ *
+ * Previously the limit was assigned onto the shared chunker singleton
+ * (`chunker.maxContentBytes = ...`) — under pLimit concurrency one file's
+ * limit could bleed into unrelated concurrent files, and it was never
+ * reset, so a later large XML/SVG file was silently skipped.
+ */
+function withByteLimit(chunker, limit) {
+    const language = chunker.language;
+    return {
+        language,
+        fileExtensions: chunker.fileExtensions,
+        async chunk(filePath, content) {
+            if (limit > 0 && Buffer.byteLength(content, "utf-8") > limit) {
+                throw new Error(`File exceeds ${limit} byte limit for ${language} chunker`);
+            }
+            return chunker.chunk(filePath, content);
+        },
+    };
 }
 /**
  * Chunk a file by looking up its registered chunker, applying node-type
@@ -203,7 +215,13 @@ export async function chunkFile(filePath, content, nodeTypesOverrides, options)
             chunker = chunker.withNodeTypes(new Set(overrideTypes));
         }
     }
-    applyChunkerConfig(chunker, filePath, options);
+    // Per-file byte limit (SVG/XML/csproj) without mutating the shared singleton
+    if (options?.maxSvgSizeBytes && chunker instanceof TreeSitterChunker) {
+        const ext = filePath.toLowerCase();
+        if (ext.endsWith(".svg") || ext.endsWith(".xml") || ext.endsWith(".csproj")) {
+            chunker = withByteLimit(chunker, options.maxSvgSizeBytes);
+        }
+    }
     const chunks = await chunker.chunk(filePath, content);
     if (chunks.length === 0) {
         return fallbackChunker.chunk(filePath, content);

package/dist/chunker/grammar.d.ts

@@ -57,6 +57,23 @@ export interface AstNode {
      */
     leadingDoc?: string;
 }
+/**
+ * Build a byte-offset → UTF-16-index map for a source string.
+ *
+ * tree-sitter reports node ranges as UTF-8 BYTE offsets, but JavaScript
+ * `String.prototype.slice` counts UTF-16 code units. For any file containing
+ * multi-byte characters the two disagree, so slicing with raw node indices
+ * truncates/garbles chunk content and doc comments. Tree-sitter node
+ * boundaries always align to code-point boundaries, so an exact map from
+ * byte offset to UTF-16 index is sufficient.
+ *
+ * Returns `null` for pure-ASCII sources (byte offsets == UTF-16 offsets),
+ * which is the common case and avoids the allocation.
+ *
+ * @param source - The full source text.
+ * @returns A Map from UTF-8 byte offset to UTF-16 index, or `null` for ASCII.
+ */
+export declare function buildByteOffsetMap(source: string): Map<number, number> | null;
 /**
  * Recursively walk a tree-sitter AST and collect nodes matching the given
  * type set.
@@ -75,4 +92,4 @@ export interface AstNode {
  * @param depth - Current recursion depth (internal, start at 0).
  * @returns An array of {@link AstNode} objects for matching declarations.
  */
-export declare function walkTree(node: Node, nodeTypes: Set<string>, source: string, maxDepth?: number, depth?: number): AstNode[];
+export declare function walkTree(node: Node, nodeTypes: Set<string>, source: string, maxDepth?: number, depth?: number, offsetMap?: Map<number, number> | null): AstNode[];

package/dist/chunker/grammar.js

@@ -120,6 +120,44 @@ const COMMENT_NODE_TYPES = new Set([
     "marginalia",
     "Comment",
 ]);
+/**
+ * Build a byte-offset → UTF-16-index map for a source string.
+ *
+ * tree-sitter reports node ranges as UTF-8 BYTE offsets, but JavaScript
+ * `String.prototype.slice` counts UTF-16 code units. For any file containing
+ * multi-byte characters the two disagree, so slicing with raw node indices
+ * truncates/garbles chunk content and doc comments. Tree-sitter node
+ * boundaries always align to code-point boundaries, so an exact map from
+ * byte offset to UTF-16 index is sufficient.
+ *
+ * Returns `null` for pure-ASCII sources (byte offsets == UTF-16 offsets),
+ * which is the common case and avoids the allocation.
+ *
+ * @param source - The full source text.
+ * @returns A Map from UTF-8 byte offset to UTF-16 index, or `null` for ASCII.
+ */
+export function buildByteOffsetMap(source) {
+    if (!/[\u0080-\uffff]/u.test(source))
+        return null;
+    const map = new Map();
+    let byteOffset = 0;
+    let utf16Index = 0;
+    for (const ch of source) {
+        map.set(byteOffset, utf16Index);
+        byteOffset += Buffer.byteLength(ch, "utf-8");
+        utf16Index += ch.length;
+    }
+    map.set(byteOffset, utf16Index);
+    return map;
+}
+/** Slice `source` by tree-sitter byte offsets, translating through the map when present. */
+function sliceByBytes(source, startByte, endByte, offsetMap) {
+    if (!offsetMap)
+        return source.slice(startByte, endByte);
+    const start = offsetMap.get(startByte) ?? startByte;
+    const end = offsetMap.get(endByte) ?? endByte;
+    return source.slice(start, end);
+}
 function cleanCommentText(text) {
     const lines = text.split("\n");
     if (text.startsWith("/*")) {
@@ -152,19 +190,19 @@ function cleanCommentText(text) {
     let cleaned = lines.map((line) => line.replace(prefix, ""));
     return cleaned.filter((l) => l.trim().length > 0).join("\n");
 }
-function extractLeadingComments(node, source) {
+function extractLeadingComments(node, source, offsetMap) {
     const comments = [];
     let sibling = node.previousSibling;
     while (sibling) {
         if (COMMENT_NODE_TYPES.has(sibling.type)) {
-            const raw = source.slice(sibling.startIndex, sibling.endIndex);
+            const raw = sliceByBytes(source, sibling.startIndex, sibling.endIndex, offsetMap);
             comments.unshift(cleanCommentText(raw));
             sibling = sibling.previousSibling;
         }
         else if (sibling.type === "expression_statement") {
             const firstChild = sibling.namedChildren[0];
             if (firstChild?.type === "string") {
-                const raw = source.slice(firstChild.startIndex, firstChild.endIndex);
+                const raw = sliceByBytes(source, firstChild.startIndex, firstChild.endIndex, offsetMap);
                 comments.unshift(cleanCommentText(raw));
                 sibling = sibling.previousSibling;
             }
@@ -180,7 +218,7 @@ function extractLeadingComments(node, source) {
         return undefined;
     return comments.join("\n\n");
 }
-function extractDocstringFromBody(node, source) {
+function extractDocstringFromBody(node, source, offsetMap) {
     if (node.type !== "function_definition" && node.type !== "class_definition") {
         return undefined;
     }
@@ -193,7 +231,7 @@ function extractDocstringFromBody(node, source) {
     const stringNode = firstStmt.namedChildren[0];
     if (!stringNode || stringNode.type !== "string")
         return undefined;
-    return cleanCommentText(source.slice(stringNode.startIndex, stringNode.endIndex));
+    return cleanCommentText(sliceByBytes(source, stringNode.startIndex, stringNode.endIndex, offsetMap));
 }
 /**
  * Recursively walk a tree-sitter AST and collect nodes matching the given
@@ -213,16 +251,16 @@ function extractDocstringFromBody(node, source) {
  * @param depth - Current recursion depth (internal, start at 0).
  * @returns An array of {@link AstNode} objects for matching declarations.
  */
-export function walkTree(node, nodeTypes, source, maxDepth = 10, depth = 0) {
+export function walkTree(node, nodeTypes, source, maxDepth = 10, depth = 0, offsetMap) {
     const results = [];
     if (nodeTypes.has(node.type) && depth > 0) {
-        const leadingComments = extractLeadingComments(node, source);
-        const bodyDocstring = extractDocstringFromBody(node, source);
+        const leadingComments = extractLeadingComments(node, source, offsetMap);
+        const bodyDocstring = extractDocstringFromBody(node, source, offsetMap);
         const leadingDoc = [leadingComments, bodyDocstring]
             .filter((d) => d !== undefined && d.length > 0)
             .join("\n\n");
         results.push({
-            text: source.slice(node.startIndex, node.endIndex),
+            text: sliceByBytes(source, node.startIndex, node.endIndex, offsetMap),
             startLine: node.startPosition.row + 1,
             endLine: node.endPosition.row + 1,
             startIndex: node.startIndex,
@@ -234,7 +272,7 @@ export function walkTree(node, nodeTypes, source, maxDepth = 10, depth = 0) {
     }
     if (depth < maxDepth) {
         for (const child of node.children) {
-            results.push(...walkTree(child, nodeTypes, source, maxDepth, depth + 1));
+            results.push(...walkTree(child, nodeTypes, source, maxDepth, depth + 1, offsetMap));
         }
     }
     return results;

package/dist/chunker/image.js

@@ -42,6 +42,7 @@ class OllamaImageVisionProvider {
     timeoutMs;
     think;
     numCtx;
+    keepAlive;
     proxy;
     constructor(config) {
         this.baseUrl = config.baseUrl.replace(/\/+$/, "");
@@ -49,6 +50,7 @@ class OllamaImageVisionProvider {
         this.timeoutMs = config.timeoutMs;
         this.think = config.think ?? false;
         this.numCtx = config.numCtx;
+        this.keepAlive = config.keepAlive;
         this.proxy = config.proxy;
     }
     async describeImage(imageBase64, _mimeType, prompt, abort) {
@@ -65,6 +67,9 @@ class OllamaImageVisionProvider {
             think: this.think,
             options: { num_ctx: this.numCtx },
         };
+        if (this.keepAlive) {
+            body.keep_alive = this.keepAlive;
+        }
         let lastError;
         for (let attempt = 0; attempt <= VISION_RETRY_MAX; attempt++) {
             const response = await postJson(`${this.baseUrl}/chat`, body, {}, this.timeoutMs, this.proxy, abort);

package/dist/chunker/pdf.js

@@ -22,19 +22,18 @@ function getStandardFontsUrl() {
  * Create a pdfjs-dist PDF document from a buffer.
  * Uses `@thednp/dommatrix` for DOMMatrix polyfill (lighter alternative to native canvas).
  * @param buffer - Raw buffer of the PDF file.
- * @returns A promise resolving to a pdfjs-dist PDFDocumentProxy.
+ * @returns The pdfjs LoadingTask for the document.
  */
-async function createPdfDocument(buffer) {
+async function getPdfLoadingTask(buffer) {
     const { default: CSSMatrix } = await import("@thednp/dommatrix");
     globalThis.DOMMatrix ??= CSSMatrix;
     globalThis.DOMMatrixReadOnly ??= CSSMatrix;
     const { getDocument } = await import("pdfjs-dist/legacy/build/pdf.mjs");
-    const loadingTask = getDocument({
+    return getDocument({
         data: new Uint8Array(buffer),
         standardFontDataUrl: getStandardFontsUrl(),
         verbosity: 0,
     });
-    return loadingTask.promise;
 }
 /**
  * Extract the full text content from a PDF file buffer.
@@ -47,17 +46,34 @@ export async function extractPdfText(buffer) {
     if (buffer.length > MAX_PDF_SIZE_BYTES) {
         throw new Error(`PDF too large: ${(buffer.length / 1024 / 1024).toFixed(1)} MB (max 100 MB)`);
     }
-    const pdf = await createPdfDocument(buffer);
-    const texts = [];
-    const pageCount = Math.min(pdf.numPages, MAX_PDF_PAGES);
-    for (let i = 1; i <= pageCount; i++) {
-        const page = await pdf.getPage(i);
-        const content = await page.getTextContent();
-        const textItems = content.items.filter((item) => typeof item === "object" && item !== null && "str" in item);
-        const strings = textItems.map((item) => item.str);
-        texts.push(strings.join(" "));
+    // loadingTask.destroy() releases the pdfjs worker/document resources —
+    // without it long-running watch/plugin processes leak them per PDF.
+    const loadingTask = await getPdfLoadingTask(buffer);
+    try {
+        const pdf = await loadingTask.promise;
+        const texts = [];
+        const pageCount = Math.min(pdf.numPages, MAX_PDF_PAGES);
+        for (let i = 1; i <= pageCount; i++) {
+            const page = await pdf.getPage(i);
+            try {
+                const content = await page.getTextContent();
+                const strings = [];
+                for (const item of content.items) {
+                    if (typeof item === "object" && item !== null && "str" in item) {
+                        strings.push(item.str);
+                    }
+                }
+                texts.push(strings.join(" "));
+            }
+            finally {
+                page.cleanup();
+            }
+        }
+        return texts.join("\n\n");
+    }
+    finally {
+        await loadingTask.destroy().catch(() => { });
     }
-    return texts.join("\n\n");
 }
 /**
  * Chunker for PDF documents (.pdf).

package/dist/cli/commands/backend-detect.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Auto-detect the Ollama backend (CPU vs GPU) during `init` and
+ * pick embedding batch settings tuned for the detected backend.
+ */
+/**
+ * Auto-detect whether Ollama runs models on the GPU or on the CPU and return
+ * matching embedding batch tuning.
+ *
+ * Detection uses `GET /api/ps`: loaded models report `size_vram` (bytes
+ * resident in VRAM). `size_vram > 0` means the model is (at least partially)
+ * offloaded to the GPU. If no model is loaded yet, a minimal `/api/embed`
+ * warmup loads the default embedding model first.
+ *
+ * Tuning is derived from benchmarks (see quirk memory):
+ * - GPU:  batch 40 + concurrency 4 ≈ 86 texts/s (~97% of the ~88 texts/s ceiling)
+ * - CPU:  flat ~3.5 texts/s regardless of batch size → small batches (20) with
+ *         concurrency 1 keep each request fast and under the 4096-token context
+ * - unreachable/unknown: defaults (100 / 3 / 100)
+ */
+import { type ProxyConfig } from "../../core/config.js";
+/** Detected Ollama backend kind. */
+export type OllamaBackend = "gpu" | "cpu" | "unreachable" | "unknown";
+/** Embedding batch settings written into the generated config. */
+export interface IndexingTuning {
+    embedBatchSize: number;
+    embedConcurrency: number;
+    ollamaMaxBatchSize: number;
+}
+/** Result of the backend detection. */
+export interface OllamaBackendInfo {
+    backend: OllamaBackend;
+    /** Tuning to write into the generated config. */
+    tuning: IndexingTuning;
+    /** Human-readable summary for the init output. */
+    message: string;
+}
+interface PsModel {
+    name: string;
+    size_vram?: number;
+}
+/**
+ * Classify loaded Ollama models into a backend + tuning profile.
+ *
+ * Prefers the configured default embedding model when it is loaded, falling
+ * back to any loaded model (a loaded GPU model means the host has a working
+ * GPU that Ollama will also use for embeddings).
+ *
+ * @param models - The `models` array from `GET /api/ps`.
+ * @returns The backend info with the matching tuning profile.
+ */
+export declare function classifyOllamaModels(models: PsModel[]): OllamaBackendInfo;
+/**
+ * Detect the Ollama backend by probing `/api/ps`, warming up the default
+ * embedding model when nothing is loaded yet.
+ *
+ * @param baseUrl - Ollama API base URL (defaults to the config default).
+ * @param proxy - Optional proxy configuration.
+ * @returns Backend info; never throws.
+ */
+export declare function detectOllamaBackend(baseUrl?: string, proxy?: ProxyConfig): Promise<OllamaBackendInfo>;
+export {};

package/dist/cli/commands/backend-detect.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Auto-detect the Ollama backend (CPU vs GPU) during `init` and
+ * pick embedding batch settings tuned for the detected backend.
+ */
+/**
+ * Auto-detect whether Ollama runs models on the GPU or on the CPU and return
+ * matching embedding batch tuning.
+ *
+ * Detection uses `GET /api/ps`: loaded models report `size_vram` (bytes
+ * resident in VRAM). `size_vram > 0` means the model is (at least partially)
+ * offloaded to the GPU. If no model is loaded yet, a minimal `/api/embed`
+ * warmup loads the default embedding model first.
+ *
+ * Tuning is derived from benchmarks (see quirk memory):
+ * - GPU:  batch 40 + concurrency 4 ≈ 86 texts/s (~97% of the ~88 texts/s ceiling)
+ * - CPU:  flat ~3.5 texts/s regardless of batch size → small batches (20) with
+ *         concurrency 1 keep each request fast and under the 4096-token context
+ * - unreachable/unknown: defaults (100 / 3 / 100)
+ */
+import { DEFAULT_CONFIG } from "../../core/config.js";
+import { fetchWithProxy, postJson } from "../../embedder/http.js";
+/** Benchmarked optimum on a GPU-backed Ollama (RTX 4090, qwen3-embedding:0.6b). */
+const GPU_TUNING = {
+    embedBatchSize: 40,
+    embedConcurrency: 4,
+    ollamaMaxBatchSize: 40,
+};
+/** CPU-backed Ollama: throughput is flat, so keep batches small and sequential. */
+const CPU_TUNING = {
+    embedBatchSize: 20,
+    embedConcurrency: 1,
+    ollamaMaxBatchSize: 20,
+};
+/** Fallback when Ollama is unreachable or the backend cannot be determined. */
+const DEFAULT_TUNING = {
+    embedBatchSize: DEFAULT_CONFIG.indexing.embedBatchSize,
+    embedConcurrency: DEFAULT_CONFIG.indexing.embedConcurrency ?? 3,
+    ollamaMaxBatchSize: DEFAULT_CONFIG.indexing.ollamaMaxBatchSize ?? 100,
+};
+/**
+ * Classify loaded Ollama models into a backend + tuning profile.
+ *
+ * Prefers the configured default embedding model when it is loaded, falling
+ * back to any loaded model (a loaded GPU model means the host has a working
+ * GPU that Ollama will also use for embeddings).
+ *
+ * @param models - The `models` array from `GET /api/ps`.
+ * @returns The backend info with the matching tuning profile.
+ */
+export function classifyOllamaModels(models) {
+    if (!models || models.length === 0) {
+        return {
+            backend: "unknown",
+            tuning: DEFAULT_TUNING,
+            message: "Could not determine the Ollama backend (no models loaded) — using default batch settings.",
+        };
+    }
+    const embedModel = DEFAULT_CONFIG.embedding.model;
+    const probe = models.find((m) => m.name === embedModel) ?? models[0];
+    const onGpu = probe ? (probe.size_vram ?? 0) > 0 : false;
+    if (onGpu) {
+        return {
+            backend: "gpu",
+            tuning: GPU_TUNING,
+            message: `Ollama detected on GPU — tuned embedding for batch 40 / concurrency 4 (${(probe?.size_vram ?? 0) / (1024 * 1024) | 0} MiB in VRAM).`,
+        };
+    }
+    return {
+        backend: "cpu",
+        tuning: CPU_TUNING,
+        message: "Ollama detected on CPU — tuned embedding for batch 20 / concurrency 1.",
+    };
+}
+/** Fetch `GET /api/ps`, returning null when Ollama is unreachable or errors. */
+async function getOllamaPs(baseUrl, proxy) {
+    const url = `${baseUrl.replace(/\/+$/, "")}/ps`;
+    try {
+        const res = await fetchWithProxy(url, { method: "GET", signal: AbortSignal.timeout(3000) }, proxy);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.models ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect the Ollama backend by probing `/api/ps`, warming up the default
+ * embedding model when nothing is loaded yet.
+ *
+ * @param baseUrl - Ollama API base URL (defaults to the config default).
+ * @param proxy - Optional proxy configuration.
+ * @returns Backend info; never throws.
+ */
+export async function detectOllamaBackend(baseUrl = DEFAULT_CONFIG.embedding.baseUrl, proxy) {
+    let models = await getOllamaPs(baseUrl, proxy);
+    if (models === null) {
+        return {
+            backend: "unreachable",
+            tuning: DEFAULT_TUNING,
+            message: "Ollama not reachable — using default batch settings.",
+        };
+    }
+    if (models.length === 0) {
+        // Nothing loaded yet: a minimal embed request loads the default
+        // embedding model so /api/ps can report its backend.
+        const embedUrl = `${baseUrl.replace(/\/+$/, "")}/embed`;
+        try {
+            await postJson(embedUrl, { model: DEFAULT_CONFIG.embedding.model, input: "warmup" }, {}, 15000, proxy);
+        }
+        catch {
+            // Model missing or request failed — classification will stay unknown.
+        }
+        models = (await getOllamaPs(baseUrl, proxy)) ?? [];
+    }
+    return classifyOllamaModels(models);
+}
+//# sourceMappingURL=backend-detect.js.map

package/dist/cli/commands/index-command.js

@@ -13,6 +13,7 @@ import readline from "node:readline";
 import chokidar from "chokidar";
 import { appendDebugLog } from "../../core/fileLogger.js";
 import { createWatchPassScheduler, createWatchIgnore, runIndexPass, } from "../../indexer.js";
+import { tryAcquireWatcherLock, releaseWatcherLock } from "../../watcher.js";
 import { c, resolveCliContext, cleanupContext, logCliError, logCliInfo, logIndexSummary, formatDuration, } from "../format.js";
 /**
  * Build a logger that suppresses console output when watchTriggered is true.
@@ -129,6 +130,15 @@ export function registerIndexCommand(program) {
                 await cleanupContext(ctx);
                 process.exit(sigReceived ? 130 : 0);
             }
+            // Only one watcher may run per workspace — a background auto-indexer
+            // in an OpenCode session (or another `index --watch`) may already own
+            // this store. The initial pass above still ran; just don't start a
+            // duplicate watcher.
+            if (!tryAcquireWatcherLock(storePath)) {
+                logCliInfo(logFilePath, "index", c.warn("Another watcher is already running for this workspace (e.g. an OpenCode session with auto-index enabled) — not starting a second one. The index is up to date."));
+                await cleanupContext(ctx);
+                process.exit(0);
+            }
             logCliInfo(logFilePath, "index", `\n${c.heading("Watching for changes...")}`);
             const scheduler = createWatchPassScheduler(async (changedPaths) => { await runPass(true, undefined, changedPaths); }, (error) => {
                 const message = error.message || String(error);
@@ -154,6 +164,7 @@ export function registerIndexCommand(program) {
                     watcher.close(),
                     new Promise((r) => setTimeout(r, 5000)),
                 ]);
+                releaseWatcherLock(storePath);
                 await cleanupContext(ctx);
                 process.exit(0);
             };

package/dist/cli/commands/init-helpers.d.ts

@@ -6,6 +6,7 @@
  * dependency installation, and gitignore merging.
  */
 import type { PackageMetadata } from "../types.js";
+import type { IndexingTuning } from "./backend-detect.js";
 /**
  * Build the workspace-local `.opencode/package.json` content.
  *
@@ -115,6 +116,8 @@ export declare function installPluginFromGlobal(opencodeDir: string, packageName
 /**
  * Generate the default `opencode-rag.json` configuration content.
  *
+ * @param tuning - Optional embedding batch tuning (auto-detected from the
+ *   Ollama backend). Falls back to `DEFAULT_CONFIG` for any omitted field.
  * @returns A pretty-printed JSON string with all default configuration values.
  */
-export declare function generateDefaultConfigJson(): string;
+export declare function generateDefaultConfigJson(tuning?: Partial<IndexingTuning>): string;

package/dist/cli/commands/init-helpers.js

@@ -379,10 +379,23 @@ export async function installPluginFromGlobal(opencodeDir, packageName, skipInst
     if (existsSync(workspaceTarget)) {
         rmSync(workspaceTarget, { recursive: true, force: true });
     }
-    // Create directory junction from workspace → global runtime
+    // Create directory junction from workspace → global runtime.
+    // Junction creation can throw (EPERM, cross-drive on Windows) — fall back
+    // to a copy instead of aborting `init`.
     console.log(`  ${c.created("Linking:")} ${packageName} from global cache...`);
     mkdirSync(path.dirname(workspaceTarget), { recursive: true });
-    createJunction(globalPluginDir, workspaceTarget);
+    try {
+        createJunction(globalPluginDir, workspaceTarget);
+    }
+    catch (err) {
+        console.log(`  ${c.warn("Junction failed, falling back to copy...")}`);
+        rmSync(workspaceTarget, { recursive: true, force: true });
+        const { cpSync } = await import("node:fs");
+        mkdirSync(path.dirname(workspaceTarget), { recursive: true });
+        cpSync(globalPluginDir, workspaceTarget, { recursive: true });
+        console.log(`  ${c.success("Copied:")} ${packageName} from global cache`);
+        return;
+    }
     const cliEntry = path.join(workspaceTarget, "dist", "cli.js");
     if (!existsSync(cliEntry)) {
         // Junction may not work (e.g. cross-drive on Windows) — fall back to copy
@@ -401,9 +414,11 @@ export async function installPluginFromGlobal(opencodeDir, packageName, skipInst
 /**
  * Generate the default `opencode-rag.json` configuration content.
  *
+ * @param tuning - Optional embedding batch tuning (auto-detected from the
+ *   Ollama backend). Falls back to `DEFAULT_CONFIG` for any omitted field.
  * @returns A pretty-printed JSON string with all default configuration values.
  */
-export function generateDefaultConfigJson() {
+export function generateDefaultConfigJson(tuning) {
     return JSON.stringify({
         embedding: {
             provider: DEFAULT_CONFIG.embedding.provider,
@@ -417,7 +432,9 @@ export function generateDefaultConfigJson() {
             chunkOverlap: DEFAULT_CONFIG.indexing.chunkOverlap,
             minFileSizeBytes: DEFAULT_CONFIG.indexing.minFileSizeBytes,
             concurrency: DEFAULT_CONFIG.indexing.concurrency,
-            embedBatchSize: DEFAULT_CONFIG.indexing.embedBatchSize,
+            embedBatchSize: tuning?.embedBatchSize ?? DEFAULT_CONFIG.indexing.embedBatchSize,
+            embedConcurrency: tuning?.embedConcurrency ?? DEFAULT_CONFIG.indexing.embedConcurrency ?? 3,
+            ollamaMaxBatchSize: tuning?.ollamaMaxBatchSize ?? DEFAULT_CONFIG.indexing.ollamaMaxBatchSize ?? 100,
         },
         vectorStore: {
             path: DEFAULT_CONFIG.vectorStore.path,