opencode-rag-plugin 1.17.0 → 1.17.3

package/dist/core/version-check.d.ts

@@ -1,9 +1,85 @@
+/**
+ * @fileoverview Version check and self-update functionality. Checks GitHub
+ * releases for new versions and installs the newest version via npm, then
+ * re-syncs the OpenCode runtime junctions.
+ */
+import { setupRuntime } from "./setup-runtime.js";
+/** Information about an available update. */
 export interface UpdateInfo {
+    /** The currently installed version string. */
     currentVersion: string;
+    /** The latest available version on GitHub. */
     latestVersion: string;
+    /** Whether a newer version than the current one exists. */
     updateAvailable: boolean;
+    /** URL to the GitHub release page. */
     releaseUrl: string;
+    /** ISO date string of when the release was published. */
     publishedAt: string;
 }
+/** Result of an install-update attempt. */
+export interface InstallUpdateResult {
+    /** Whether the install completed successfully. */
+    success: boolean;
+    /** Human-readable status message. */
+    message: string;
+    /** Version before the update. */
+    fromVersion: string;
+    /** Version after the update (undefined if the install failed). */
+    toVersion?: string;
+}
+/** Callable shape for the npm runner (a subset of execSync's signature). */
+type NpmRunner = (command: string, options: {
+    stdio: "inherit" | "pipe";
+    timeout: number;
+}) => unknown;
+/**
+ * Read the current version from the package.json sitting next to this module.
+ *
+ * Resolves the package root via `import.meta.url` so it works both from the
+ * source tree and from the compiled `dist/` output. Returns `"0.0.0"` if the
+ * file cannot be read or parsed (best-effort — never throws).
+ *
+ * @returns The current package version string.
+ */
+export declare function getCurrentVersion(): string;
+/**
+ * Compare two semver-ish strings.
+ * @returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
 export declare function compareVersions(a: string, b: string): number;
+/**
+ * Check the GitHub releases API for a newer version of OpenCodeRAG.
+ *
+ * Uses a 5-second timeout; failures (network errors, non-OK responses, missing
+ * `tag_name`) are silently caught and reported as "no update available" so the
+ * caller never has to handle a rejection.
+ *
+ * @param currentVersion - The version string to compare against.
+ * @returns UpdateInfo indicating whether an update is available.
+ */
 export declare function checkForUpdate(currentVersion: string): Promise<UpdateInfo>;
+/**
+ * Install the newest published version of OpenCodeRAG.
+ *
+ * Runs `npm install -g <package>@latest` to refresh the global install, then
+ * calls {@link setupRuntime} with `force: true` to re-create the
+ * `~/.opencode/node_modules/` junctions so OpenCode picks up the new build on
+ * the next restart.
+ *
+ * @param options - Optional verbosity flag. When `verbose` is true, npm output
+ *   is streamed to the console; otherwise it is captured silently. The
+ *   `_execSync` and `_setupRuntime` seams are for testing only.
+ * @returns An {@link InstallUpdateResult} with success status, message, and the
+ *   from/to versions.
+ */
+export declare function installLatestUpdate(options?: {
+    verbose?: boolean;
+    /** Test seam: override the npm runner. */
+    _execSync?: NpmRunner;
+    /** Test seam: override the runtime sync. */
+    _setupRuntime?: typeof setupRuntime;
+    /** Test seam: override the version reader for the "to" version. */
+    _getCurrentVersion?: typeof getCurrentVersion;
+}): Promise<InstallUpdateResult>;
+export {};

package/dist/core/version-check.js

@@ -1,3 +1,45 @@
+/**
+ * @fileoverview Version check and self-update functionality. Checks GitHub
+ * releases for new versions and installs the newest version via npm, then
+ * re-syncs the OpenCode runtime junctions.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { setupRuntime } from "./setup-runtime.js";
+/** npm package name (must match the `name` field in package.json). */
+const PACKAGE_NAME = "opencode-rag-plugin";
+/** GitHub repo used for release checks (owner/repo). */
+const GITHUB_REPO = "MrDoe/OpenCodeRAG";
+const GITHUB_API_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+/**
+ * Read the current version from the package.json sitting next to this module.
+ *
+ * Resolves the package root via `import.meta.url` so it works both from the
+ * source tree and from the compiled `dist/` output. Returns `"0.0.0"` if the
+ * file cannot be read or parsed (best-effort — never throws).
+ *
+ * @returns The current package version string.
+ */
+export function getCurrentVersion() {
+    try {
+        const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** Strip a leading 'v' or 'V' prefix from a version tag. */
+function normalizeVersion(tag) {
+    return tag.replace(/^v/i, "");
+}
+/**
+ * Compare two semver-ish strings.
+ * @returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
 export function compareVersions(a, b) {
     const pa = a.split(".").map((s) => parseInt(s, 10));
     const pb = b.split(".").map((s) => parseInt(s, 10));
@@ -11,11 +53,21 @@ export function compareVersions(a, b) {
     }
     return 0;
 }
+/**
+ * Check the GitHub releases API for a newer version of OpenCodeRAG.
+ *
+ * Uses a 5-second timeout; failures (network errors, non-OK responses, missing
+ * `tag_name`) are silently caught and reported as "no update available" so the
+ * caller never has to handle a rejection.
+ *
+ * @param currentVersion - The version string to compare against.
+ * @returns UpdateInfo indicating whether an update is available.
+ */
 export async function checkForUpdate(currentVersion) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5_000);
     try {
-        const response = await fetch("https://api.github.com/repos/MrDoe/OpenCodeRAG/releases/latest", {
+        const response = await fetch(GITHUB_API_URL, {
             headers: {
                 Accept: "application/vnd.github+json",
                 "User-Agent": "opencode-rag-updater",
@@ -30,7 +82,7 @@ export async function checkForUpdate(currentVersion) {
         if (!tagName) {
             return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
         }
-        const latestVersion = tagName.replace(/^v/i, "");
+        const latestVersion = normalizeVersion(tagName);
         return {
             currentVersion,
             latestVersion,
@@ -46,4 +98,63 @@ export async function checkForUpdate(currentVersion) {
         clearTimeout(timeout);
     }
 }
+/**
+ * Install the newest published version of OpenCodeRAG.
+ *
+ * Runs `npm install -g <package>@latest` to refresh the global install, then
+ * calls {@link setupRuntime} with `force: true` to re-create the
+ * `~/.opencode/node_modules/` junctions so OpenCode picks up the new build on
+ * the next restart.
+ *
+ * @param options - Optional verbosity flag. When `verbose` is true, npm output
+ *   is streamed to the console; otherwise it is captured silently. The
+ *   `_execSync` and `_setupRuntime` seams are for testing only.
+ * @returns An {@link InstallUpdateResult} with success status, message, and the
+ *   from/to versions.
+ */
+export async function installLatestUpdate(options) {
+    const verbose = options?.verbose ?? false;
+    const stdio = verbose ? "inherit" : "pipe";
+    const run = options?._execSync ?? execSync;
+    const syncRuntime = options?._setupRuntime ?? setupRuntime;
+    const readVersion = options?._getCurrentVersion ?? getCurrentVersion;
+    const fromVersion = readVersion();
+    try {
+        run(`npm install -g ${PACKAGE_NAME}@latest --no-fund --no-audit`, {
+            stdio,
+            timeout: 120_000,
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `npm install failed: ${err.message}`,
+            fromVersion,
+        };
+    }
+    const toVersion = readVersion();
+    const result = await syncRuntime({ force: true, silent: !verbose, version: toVersion });
+    if (!result.success) {
+        return {
+            success: false,
+            message: `installed v${toVersion} but runtime sync failed: ${result.errors.join("; ")}. Run \`opencode-rag setup\` to retry.`,
+            fromVersion,
+            toVersion,
+        };
+    }
+    if (compareVersions(toVersion, fromVersion) <= 0) {
+        return {
+            success: true,
+            message: `Already up-to-date (v${toVersion}). Runtime re-synced.`,
+            fromVersion,
+            toVersion,
+        };
+    }
+    return {
+        success: true,
+        message: `Updated v${fromVersion} → v${toVersion}. Restart OpenCode to load the new version.`,
+        fromVersion,
+        toVersion,
+    };
+}
 //# sourceMappingURL=version-check.js.map

package/dist/embedder/cohere.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - Cohere API base URL
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export declare class CohereProvider implements EmbeddingProvider {

package/dist/embedder/cohere.js

@@ -5,7 +5,7 @@ import { postJson } from "./http.js";
  * @param baseUrl - Cohere API base URL
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export class CohereProvider {
@@ -15,7 +15,7 @@ export class CohereProvider {
     apiKey;
     timeoutMs;
     proxy;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/embedder/factory.js

@@ -16,7 +16,7 @@ import pLimit from "p-limit";
  */
 export function createEmbedder(config) {
     const { provider, baseUrl, model, apiKey, proxy, timeoutMs } = config.embedding;
-    const effectiveTimeoutMs = timeoutMs ?? 30000;
+    const effectiveTimeoutMs = timeoutMs ?? 120000;
     if (provider === "ollama") {
         return new OllamaProvider(baseUrl, model, apiKey, effectiveTimeoutMs, proxy, config.logging.level);
     }

package/dist/embedder/health.js

@@ -4,7 +4,7 @@ import { postJson } from "./http.js";
  * Returns one result per configured model (embedding + description + image_description if enabled).
  */
 export async function checkProviderHealth(config) {
-    const timeoutMs = config.embedding.timeoutMs ?? 30000;
+    const timeoutMs = config.embedding.timeoutMs ?? 120000;
     const checks = [
         checkEmbeddingModel(config, timeoutMs),
     ];

package/dist/embedder/ollama.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - Ollama server base URL (e.g. http://localhost:11434)
  * @param model - Model name to use for embedding
  * @param apiKey - Optional API key for authenticated endpoints
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+   * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  * @param logLevel - Optional logging level for debug output
  */

package/dist/embedder/ollama.js

@@ -7,7 +7,7 @@ import { appendDebugLog } from "../core/fileLogger.js";
  * @param baseUrl - Ollama server base URL (e.g. http://localhost:11434)
  * @param model - Model name to use for embedding
  * @param apiKey - Optional API key for authenticated endpoints
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+   * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  * @param logLevel - Optional logging level for debug output
  */
@@ -19,7 +19,7 @@ export class OllamaProvider {
     timeoutMs;
     proxy;
     logLevel;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy, logLevel) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy, logLevel) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/embedder/openai.d.ts

@@ -9,7 +9,7 @@ import type { ProxyConfig } from "../core/config.js";
  * @param baseUrl - API base URL (e.g. https://api.openai.com/v1)
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export declare class OpenAIProvider implements EmbeddingProvider {

package/dist/embedder/openai.js

@@ -16,7 +16,7 @@ function inferProviderName(baseUrl) {
  * @param baseUrl - API base URL (e.g. https://api.openai.com/v1)
  * @param model - Model name to use for embedding
  * @param apiKey - API key for authentication
- * @param timeoutMs - Request timeout in milliseconds (default 30000)
+ * @param timeoutMs - Request timeout in milliseconds (default 120000)
  * @param proxy - Optional proxy configuration
  */
 export class OpenAIProvider {
@@ -27,7 +27,7 @@ export class OpenAIProvider {
     timeoutMs;
     proxy;
     provider;
-    constructor(baseUrl, model, apiKey, timeoutMs = 30000, proxy) {
+    constructor(baseUrl, model, apiKey, timeoutMs = 120000, proxy) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.model = model;
         this.apiKey = apiKey;

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export type { ContextOptimizationConfig, ContextOptimizationOptions } from "./re
  */
 export { search, indexWorkspace, getContext, validateConfig, scanWorkspace, getIndexStatusSummary } from "./api.js";
 export type { SearchOptions, IndexOptions, ContextResult, ConfigValidationResult, WorkspaceFile, IndexRunStats } from "./api.js";
+/** Version check and self-update API. */
+export { checkForUpdate, getCurrentVersion, installLatestUpdate, compareVersions } from "./core/version-check.js";
+export type { UpdateInfo, InstallUpdateResult } from "./core/version-check.js";
 /** The plugin server configuration object, used to register OpenCodeRAG as an OpenCode plugin. */
 export declare const server: import("@opencode-ai/plugin").Plugin;
 /** Unique identifier for the OpenCodeRAG plugin. */

package/dist/index.js

@@ -21,6 +21,8 @@ export { DescriptionCache } from "./core/desc-cache.js";
  * @module
  */
 export { search, indexWorkspace, getContext, validateConfig, scanWorkspace, getIndexStatusSummary } from "./api.js";
+/** Version check and self-update API. */
+export { checkForUpdate, getCurrentVersion, installLatestUpdate, compareVersions } from "./core/version-check.js";
 /** Plugin entry — only importable inside OpenCode's runtime. */
 import { ragPlugin } from "./plugin.js";
 /** The plugin server configuration object, used to register OpenCodeRAG as an OpenCode plugin. */

package/dist/indexer/pipeline.js

@@ -210,10 +210,17 @@ async function runIndexPassInner(options, logger) {
             effectiveStore = createVectorStore(options.config, tempStorePath, options.dimension);
             logger.debug(`Rebuilding index in temporary store at ${tempStorePath}`);
         }
+        else if (existingCount > 0) {
+            // NEVER destroy existing data when we can't do an atomic rebuild.
+            // Abort and ask the user to run 'opencode-rag index --force' manually.
+            logger.warn("Cannot rebuild safely without embedding dimension — aborting to protect existing data. " +
+                "Run 'opencode-rag index --force' manually to rebuild.");
+            // Restore manifest entries we just deleted so the next pass can retry incrementally
+            return createIndexStats(workspaceFiles.length, manifestStatus);
+        }
         else {
-            // Fallback — in-memory store or no dimension: clear in place.
-            logger.warn("No embedding dimension available; falling back to in-place clear.");
-            await options.store.clear();
+            // No existing data — safe to proceed with in-place indexing (no clear needed)
+            logger.debug("No existing data; indexing from scratch.");
         }
     }
     const stats = createIndexStats(workspaceFiles.length, manifestStatus);
@@ -518,7 +525,7 @@ async function runIndexPassInner(options, logger) {
     }
     // ── Phase 2: Embed all texts in a single batched call ──────────────────
     const batchSize = isOllama
-        ? Math.min(options.config.indexing.ollamaMaxBatchSize ?? 4000, defaultBatchSize)
+        ? Math.min(options.config.indexing.ollamaMaxBatchSize ?? 500, defaultBatchSize)
         : defaultBatchSize;
     let embeddedDone = 0;
     const allTexts = embedQueue.map(item => item.text);
@@ -556,6 +563,8 @@ async function runIndexPassInner(options, logger) {
         }
     }
     // ── Phase 3: Store + manifest update per file (parallel) ──────────────
+    const filesToStore = prepared.filter((p) => !earlyWorkerResults.has(prepared.indexOf(p)) && p.chunks && (p.textToEmbed?.length ?? 0) > 0).length;
+    let storedFiles = 0;
     const storeLimit = pLimit(options.config.indexing.concurrency);
     const storeResults = await Promise.all(prepared.map((prep, fi) => storeLimit(async () => {
         if (aborted()) {
@@ -618,6 +627,8 @@ async function runIndexPassInner(options, logger) {
             enqueueManifestSave();
         }
         options.progress?.finishFile(prep.fileLabel);
+        storedFiles++;
+        logChunkProgress("Storing", prep.fileLabel, storedFiles, filesToStore, storedFiles, filesToStore);
         return result;
     })));
     const workerResults = storeResults;

package/dist/plugin.js

@@ -22,9 +22,10 @@ import { loadDocProgress, markSubdirectoryDocumented } from "./core/doc-progress
 import { loadManifest } from "./core/manifest.js";
 import { createSessionLogger } from "./eval/session-logger.js";
 import { countTokens } from "./eval/token-counter.js";
-import { checkForUpdate } from "./core/version-check.js";
+import { checkForUpdate, getCurrentVersion, installLatestUpdate } from "./core/version-check.js";
+import { loadAutoUpdateState, saveAutoUpdateState, shouldAttemptInstall } from "./core/auto-update-state.js";
 import { destroyAllPooledConnections } from "./embedder/http.js";
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, execSync } from "node:child_process";
@@ -39,6 +40,10 @@ const backgroundIndexers = new Map();
 const mcpServers = new Map();
 /** Pending update notifications keyed by workspace directory. */
 const pendingUpdateInfo = new Map();
+/** Workspace directories that have already been prompted about an update this session. */
+const notifiedUpdateDirs = new Set();
+/** Pending "restart needed" notice after a background auto-install. */
+const pendingRestartNotice = new Map();
 /** Guard flag to prevent re-entrant shutdown. */
 let shutdownRegistered = false;
 /** Close all active background indexers and MCP servers, then destroy idle sockets. */
@@ -59,6 +64,8 @@ async function shutdownPluginResources() {
     }
     configCache.clear();
     pendingUpdateInfo.clear();
+    pendingRestartNotice.clear();
+    notifiedUpdateDirs.clear();
     destroyAllPooledConnections();
 }
 /** Register a process.beforeExit handler so that resources are cleaned up
@@ -685,17 +692,37 @@ export function createRagHooks(options) {
                 ];
                 output.system.unshift(guidance.join("\n"));
             }
-            // Inject update notification if available
+            // Inject a one-time update prompt so the agent asks the user to install.
+            // Fires only once per workspace per session to avoid nagging on every turn.
             const updateInfo = pendingUpdateInfo.get(options.worktree);
-            if (updateInfo) {
-                output.system.unshift(`OpenCodeRAG update available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}. ` +
-                    `Run \`npm update -g opencode-rag-plugin && opencode-rag setup\` to install.`);
+            if (updateInfo && !notifiedUpdateDirs.has(options.worktree)) {
+                notifiedUpdateDirs.add(options.worktree);
+                pendingUpdateInfo.delete(options.worktree);
+                output.system.unshift(`A newer OpenCodeRAG version is available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}. ` +
+                    `At the very start of your next response, briefly tell the user a new version is available and ask whether ` +
+                    `they would like you to install it. If they agree, run \`opencode-rag update\` via the bash tool, then tell ` +
+                    `them to restart OpenCode to load the new version. Do not mention this notice again.`);
+            }
+            // Inject a one-time "restart needed" notice after a background auto-install.
+            // Fires only once per workspace per session, mirroring the notify-only pattern above.
+            const restartInfo = pendingRestartNotice.get(options.worktree);
+            if (restartInfo && !notifiedUpdateDirs.has(options.worktree + ":restart")) {
+                notifiedUpdateDirs.add(options.worktree + ":restart");
+                pendingRestartNotice.delete(options.worktree);
+                output.system.unshift(`OpenCodeRAG was automatically updated from v${restartInfo.fromVersion} to v${restartInfo.toVersion} ` +
+                    `in the background. At the very start of your next response, tell the user the update was installed ` +
+                    `and ask them to restart OpenCode to load the new version. Do not mention this notice again.`);
             }
             // Inject documentation mode system prompt if enabled
             const docMode = getEffectiveCfg().documentationMode;
             if (docMode?.enabled && docMode.systemPrompt) {
                 output.system.unshift(docMode.systemPrompt);
             }
+            // Inject wiki mode system prompt if enabled
+            const wikiMode = getEffectiveCfg().wikiMode;
+            if (wikiMode?.enabled && wikiMode.systemPrompt) {
+                output.system.unshift(wikiMode.systemPrompt);
+            }
         },
         async "chat.message"(input, output) {
             try {
@@ -797,6 +824,64 @@ export function createRagHooks(options) {
                     }
                     return;
                 }
+                // Handle /wiki slash command
+                if (text.startsWith("/wiki")) {
+                    const wikiMode = getEffectiveCfg().wikiMode;
+                    if (!wikiMode?.enabled) {
+                        const parts = output?.parts ?? output?.message?.parts;
+                        if (Array.isArray(parts) && parts.length > 0) {
+                            const first = parts[0];
+                            if (typeof first.text === "string") {
+                                parts[0] = { ...first, text: "Wiki mode is not enabled. Set `wikiMode.enabled` to `true` in opencode-rag.json." };
+                            }
+                        }
+                        return;
+                    }
+                    const arg = text.slice(5).trim().toLowerCase();
+                    const wikiDir = path.join(options.worktree, ".opencode", "wiki");
+                    const lines = [];
+                    if (arg === "lint") {
+                        lines.push("## Wiki Lint", "", "Run a health check on the wiki. Check for:", "- Orphan pages with no inbound [[links]]", "- Stale pages whose sourceRefs files changed since lastReviewed", "- Contradictions between pages", "- Important concepts mentioned but lacking their own page", "", "Append findings to .opencode/wiki/log.md and fix any issues found.");
+                    }
+                    else if (arg === "seed") {
+                        lines.push("## Wiki Seed", "", "Generate the initial wiki from existing sources:", "1. Read README and top-level docs for project overview → create overview page", "2. Scan file structure with get_file_skeleton for major modules → create entity pages", "3. Identify common conventions from code patterns → create concept pages", "4. Create .opencode/wiki/index.md listing all pages", "5. Create .opencode/wiki/log.md with initial entry", "6. Keep pages focused — one concept per page, short prose, cross-referenced with [[links]]");
+                    }
+                    else {
+                        if (existsSync(wikiDir)) {
+                            const entries = readdirSync(wikiDir);
+                            const pages = entries.filter((e) => e.endsWith(".md") && e !== "log.md").length;
+                            const hasIndex = entries.includes("index.md");
+                            const hasLog = entries.includes("log.md");
+                            const dirs = entries.filter((e) => !e.includes(".")).length;
+                            let lastLogEntry = "";
+                            const logPath = path.join(wikiDir, "log.md");
+                            if (hasLog && existsSync(logPath)) {
+                                const logContent = readFileSync(logPath, "utf-8");
+                                const logLines = logContent.trim().split("\n").filter((l) => l.startsWith("## ["));
+                                if (logLines.length > 0) {
+                                    lastLogEntry = logLines[logLines.length - 1] ?? "";
+                                }
+                            }
+                            lines.push("## Wiki Status", "", `Wiki: \`.opencode/wiki/\``, `Pages: ~${pages} (.md files)`, `Subdirectories: \`${dirs}\``, `Index: ${hasIndex ? "yes" : "no"} | Log: ${hasLog ? "yes" : "no"}`);
+                            if (lastLogEntry) {
+                                lines.push(`Latest log: \`${lastLogEntry}\``);
+                            }
+                            lines.push("", "Commands:", "- `/wiki` — show this status", "- `/wiki lint` — health-check the wiki", "- `/wiki seed` — generate initial wiki pages from the codebase");
+                        }
+                        else {
+                            lines.push("## Wiki Status", "", "No wiki yet at `.opencode/wiki/`.", "Use `/wiki seed` to generate the initial wiki from existing sources.");
+                        }
+                    }
+                    const wikiMsg = lines.join("\n");
+                    const parts = output?.parts ?? output?.message?.parts;
+                    if (Array.isArray(parts) && parts.length > 0) {
+                        const first = parts[0];
+                        if (typeof first.text === "string") {
+                            parts[0] = { ...first, text: wikiMsg };
+                        }
+                    }
+                    return;
+                }
                 // Handle hotkey-triggered RAG injection (Ctrl+Enter / Ctrl+Alt+Enter)
                 const pendingInjection = consumePendingRagInjection(options.storePath);
                 if (pendingInjection) {
@@ -1090,6 +1175,8 @@ export const ragPlugin = async (input, _options) => {
     // Clean up stale config cache and pending update info for this directory
     configCache.delete(input.directory);
     pendingUpdateInfo.delete(input.directory);
+    pendingRestartNotice.delete(input.directory);
+    notifiedUpdateDirs.delete(input.directory);
     // Clean up idle HTTP sockets from previous provider connections
     destroyAllPooledConnections();
     appendDebugLog(logFilePath, {
@@ -1165,6 +1252,7 @@ export const ragPlugin = async (input, _options) => {
             logLevel,
             keywordIndex,
             descriptionProvider,
+            dimension: vectorDimension,
         });
         backgroundIndexers.set(input.directory, indexer);
     }
@@ -1180,28 +1268,87 @@ export const ragPlugin = async (input, _options) => {
             catch { /* ignore */ }
         }
     }
-    // Auto-start MCP server if enabled (skip in temp dirs / test environments)
-    const mcpCfg = effectiveCfg.mcp ?? { enabled: true };
+    // Auto-start standalone MCP server if enabled (default: off). Agent tools
+    // (search_semantic, get_file_skeleton, find_usages, describe_image) and the
+    // chat.message hook run in-process regardless. Enable only when an external
+    // MCP client connects to `opencode-rag mcp`.
+    const mcpCfg = effectiveCfg.mcp ?? { enabled: false };
     const isTempDir = path.resolve(input.directory).startsWith(tmpdir());
     if (mcpCfg.enabled && !isTempDir) {
         const mcpInstance = startMcpServerProcess(input.directory, logFilePath, logLevel);
         mcpServers.set(input.directory, mcpInstance);
     }
-    // Auto-update check (non-blocking, best-effort)
+    // Auto-update check (non-blocking, best-effort). On by default; can be
+    // disabled via `autoUpdate.enabled: false` in opencode-rag.json. When a newer
+    // release is found it is either surfaced as a one-time install prompt via
+    // the system transform hook (default) or automatically installed in the
+    // background when `autoUpdate.autoInstall: true` is configured.
     const autoUpdateCfg = effectiveCfg.autoUpdate;
     if (autoUpdateCfg?.enabled) {
-        const currentVersion = (() => {
-            try {
-                const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-                return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
-            }
-            catch {
-                return "0.0.0";
-            }
-        })();
+        const currentVersion = getCurrentVersion();
         checkForUpdate(currentVersion)
             .then((info) => {
-            if (info.updateAvailable) {
+            if (!info.updateAvailable)
+                return;
+            if (autoUpdateCfg?.autoInstall) {
+                // Background auto-install branch (opt-in). Persist a cooldown file
+                // so we don't re-install on every plugin reload or after failures.
+                const cooldownMs = autoUpdateCfg.cooldownMs ?? 3_600_000;
+                const maxFailures = autoUpdateCfg.maxConsecutiveFailures ?? 3;
+                const state = loadAutoUpdateState(storePath);
+                const { attempt, reason } = shouldAttemptInstall(state, info.latestVersion, cooldownMs, maxFailures);
+                if (!attempt) {
+                    appendDebugLog(logFilePath, {
+                        scope: "updater",
+                        message: `Auto-install skipped: ${reason}`,
+                    }, logLevel);
+                    return;
+                }
+                saveAutoUpdateState(storePath, {
+                    lastAttemptAt: Date.now(),
+                    lastAttemptedVersion: info.latestVersion,
+                    lastResult: "failure",
+                    consecutiveFailures: 1,
+                });
+                installLatestUpdate({ verbose: false })
+                    .then((result) => {
+                    if (result.success && result.toVersion && result.toVersion !== currentVersion) {
+                        pendingRestartNotice.set(input.directory, {
+                            fromVersion: currentVersion,
+                            toVersion: result.toVersion,
+                        });
+                        saveAutoUpdateState(storePath, {
+                            lastAttemptAt: Date.now(),
+                            lastAttemptedVersion: info.latestVersion,
+                            lastResult: "success",
+                            consecutiveFailures: 0,
+                        });
+                        appendDebugLog(logFilePath, {
+                            scope: "updater",
+                            message: `Auto-installed v${currentVersion} → v${result.toVersion}`,
+                        }, logLevel);
+                    }
+                    else {
+                        saveAutoUpdateState(storePath, {
+                            lastAttemptAt: Date.now(),
+                            lastAttemptedVersion: info.latestVersion,
+                            lastResult: "success",
+                            consecutiveFailures: 0,
+                        });
+                    }
+                })
+                    .catch(() => {
+                    const existing = loadAutoUpdateState(storePath);
+                    saveAutoUpdateState(storePath, {
+                        lastAttemptAt: Date.now(),
+                        lastAttemptedVersion: info.latestVersion,
+                        lastResult: "failure",
+                        consecutiveFailures: (existing?.consecutiveFailures ?? 0) + 1,
+                    });
+                });
+            }
+            else {
+                // Notify-only: surface as a one-time agent prompt
                 pendingUpdateInfo.set(input.directory, info);
                 appendDebugLog(logFilePath, {
                     scope: "updater",