@openviking/opencode-plugin 0.1.6 → 0.2.1

package/README.md

@@ -4,17 +4,17 @@ A unified OpenCode plugin for OpenViking repository retrieval and long-term memo
 
 This is the only OpenCode plugin example maintained in this repository. It supersedes the former split examples for indexed repository prompt injection and long-term memory.
 
-The new plugin exposes everything through OpenCode tool hooks and talks to OpenViking through HTTP APIs. It does not install or require an OpenCode skill, and agents do not need to run `ov` shell commands.
+The plugin uses OpenCode hooks for lifecycle behavior and registers OpenViking's standard stdio MCP proxy for model tools. It does not install or require an OpenCode skill, and agents do not need to run `ov` shell commands.
 
 ## What It Does
 
 - Injects indexed `viking://resources/` repositories into the system prompt.
-- Exposes repository search, grep, glob, read, browse, add, write, remove, and queue status as tools.
+- Exposes the same OpenViking MCP tools used by the Claude Code and Codex memory plugins.
 - Maps each OpenCode session to an OpenViking session.
 - Captures user and assistant text messages into OpenViking.
 - Commits sessions at lifecycle boundaries for memory extraction.
 - Automatically recalls relevant memories and injects them as hidden synthetic context for the current user message.
-- Blocks accidental local filesystem reads of `viking://` URIs and points the agent back to `memread`, `membrowse`, or `memsearch`.
+- Blocks accidental local filesystem reads of `viking://` URIs and points the agent back to `openviking_read`, `openviking_glob`, or `openviking_search`.
 
 ## Files
 
@@ -25,26 +25,29 @@ examples/opencode-plugin/
 ├── README.md
 ├── INSTALL-ZH.md
 ├── lib/
+│   ├── config.mjs
+│   ├── mcp-config.mjs
 │   ├── runtime.mjs
 │   ├── repo-context.mjs
 │   ├── memory-session.mjs
-│   ├── memadd-local.mjs
-│   ├── memory-tools.mjs
 │   ├── memory-recall.mjs
+│   ├── session-inject.mjs
 │   ├── viking-uri-guard.mjs
 │   └── utils.mjs
+├── servers/
+│   └── mcp-proxy.mjs
 ├── tests/
 └── wrappers/
     └── openviking.js
 ```
 
-There is intentionally no `skills/openviking/SKILL.md`. The former skill behavior is implemented as tools.
+There is intentionally no `skills/openviking/SKILL.md`. The tool surface comes from OpenViking's MCP endpoint.
 
 ## Requirements
 
 - OpenCode
 - OpenViking HTTP server
-- Node.js / npm for installing the plugin dependency
+- Node.js 18+
 - An OpenViking API key if your server requires authentication
 
 Start OpenViking first:
@@ -80,8 +83,7 @@ mkdir -p ~/.config/opencode/plugins/openviking
 cp examples/opencode-plugin/wrappers/openviking.js ~/.config/opencode/plugins/openviking.js
 cp examples/opencode-plugin/index.mjs examples/opencode-plugin/package.json ~/.config/opencode/plugins/openviking/
 cp -r examples/opencode-plugin/lib ~/.config/opencode/plugins/openviking/
-cd ~/.config/opencode/plugins/openviking
-npm install
+cp -r examples/opencode-plugin/servers ~/.config/opencode/plugins/openviking/
 ```
 
 This creates a stable OpenCode plugin layout:
@@ -93,7 +95,7 @@ This creates a stable OpenCode plugin layout:
     ├── index.mjs
     ├── package.json
     ├── lib/
-    └── node_modules/
+    └── servers/
 ```
 
 The top-level `openviking.js` is only a wrapper:
@@ -111,151 +113,80 @@ Create `~/.config/opencode/openviking-config.json`:
 
 ```json
 {
-  "endpoint": "http://localhost:1933",
-  "apiKey": "",
-  "account": "",
-  "user": "",
-  "peerId": "",
   "enabled": true,
   "timeoutMs": 30000,
   "repoContext": { "enabled": true, "cacheTtlMs": 60000 },
   "autoRecall": {
     "enabled": true,
     "limit": 6,
-    "scoreThreshold": 0.15,
+    "scoreThreshold": 0.35,
     "maxContentChars": 500,
     "preferAbstract": true,
-    "tokenBudget": 2000
-  }
+    "tokenBudget": 2000,
+    "minQueryLength": 3
+  },
+  "commitTokenThreshold": 20000,
+  "commitKeepRecentCount": 10,
+  "profileTokenBudget": 10000,
+  "resumeContextBudget": 32000
 }
 ```
 
-`apiKey` is sent as `X-API-Key`. `account` and `user` are trusted-mode identity
+API keys are resolved from environment variables or `~/.openviking/ovcli.conf` and sent as `Authorization: Bearer ...` by both hooks and the MCP proxy. `account` and `user` are trusted-mode identity
 headers sent as `X-OpenViking-Account` and `X-OpenViking-User`; leave them empty
 when using API-key mode with user/admin API keys.
-`peerId` is sent as `X-OpenViking-Actor-Peer` on data-plane memory/resource
-requests; captured session messages store it as body `peer_id`. Configure
-`peerId` explicitly when peer-scoped memory routing is needed.
+By default the plugin derives a peer from the project directory using Claude's
+project-directory naming rule: every non-letter-or-digit character becomes `-`,
+with no path normalization. For example, `/Users/x/Dev/OpenViking` becomes
+`-Users-x-Dev-OpenViking`. Data-plane memory/resource requests send the
+effective peer as `X-OpenViking-Actor-Peer`; captured session messages store it
+as body `peer_id`. Configure `peerId` or `OPENVIKING_PEER_ID` to override the
+workspace-derived peer, or set `workspacePeer=false` /
+`OPENVIKING_WORKSPACE_PEER=0` to turn workspace-derived peers off.
+
+Recall defaults to the broad mode: global memory, the current workspace, and
+other workspace memories can all be recalled, with other workspaces penalized
+and rendered later. Set `recallPeerScope="actor"` or
+`OPENVIKING_RECALL_PEER_SCOPE=actor` for the isolation mode, which only sees
+global memory plus the current workspace. In deployments where one bot serves
+multiple real people, such as zouk, vikingbot, or AstrBot, use the isolation mode
+with an explicit actor peer so one person's memories are not recalled into
+another person's session.
 
 `OPENVIKING_API_KEY`, `OPENVIKING_ACCOUNT`, `OPENVIKING_USER`,
-and `OPENVIKING_PEER_ID` take
-precedence over values in this file.
+and `OPENVIKING_PEER_ID` take precedence over values in this file.
 
 For advanced setups, `OPENVIKING_PLUGIN_CONFIG` can point to another config file path.
 
 OpenCode's local `read`, `glob`, and `grep` tools cannot read `viking://` URIs.
 When the agent accidentally tries that, the plugin blocks the filesystem tool
-call and points it to `memread`, `membrowse`, or `memsearch`.
+call and points it to the OpenViking MCP tools.
 
-## Tools
+## MCP Tools
 
-### `memsearch`
+OpenCode sees the OpenViking MCP server as `openviking`, so tool names are namespaced with `openviking_`.
 
-Semantic search across memories, resources, and skills.
+- `openviking_recall`: balanced current-task recall using OpenViking's `/recall` endpoint.
+- `openviking_search`: deep semantic retrieval across memories, resources, and skills.
+- `openviking_find`: fast semantic retrieval.
+- `openviking_remember`: store important facts or decisions for memory extraction.
+- `openviking_read`: read one or more `viking://` files.
+- `openviking_list`: list a `viking://` directory.
+- `openviking_grep`: exact text or regex search.
+- `openviking_glob`: glob file matching.
+- `openviking_add_resource`: add a URL, local file, sitemap, or feed.
+- `openviking_forget`: delete a `viking://` URI after explicit user confirmation.
+- `openviking_list_watches` / `openviking_cancel_watch`: inspect or cancel resource watches.
+- `openviking_code_search`, `openviking_code_outline`, `openviking_code_expand`: inspect indexed code symbols.
+- `openviking_health`: check OpenViking server health.
 
-Use for conceptual questions, repository internals, user preferences, and context-aware retrieval. Use `target_uri` to narrow scope, for example `viking://resources/fastapi/`.
-
-### `memread`
-
-Read a specific `viking://` URI using `abstract`, `overview`, `read`, or `auto`.
-
-Use after `memsearch`, `memgrep`, `memglob`, or `membrowse` returns a URI.
-
-### `membrowse`
-
-Browse OpenViking filesystem structure with `list`, `tree`, or `stat`.
-
-Use to discover exact URIs before reading content.
-
-### `memcommit`
-
-Commit the current OpenCode session to OpenViking and trigger memory extraction.
-
-The plugin also commits at session deletion, session error, compaction, and plugin shutdown boundaries.
-
-### `memgrep`
-
-Pattern search through OpenViking content.
-
-Use for exact symbols, class names, function names, error strings, or known keywords.
-
-### `memglob`
-
-Glob file matching through OpenViking content.
-
-Use to enumerate files such as `**/*.py`, `**/test_*.ts`, or `**/*.md`.
-
-### `memadd`
-
-Add a remote URL or local file resource to OpenViking.
-
-Remote `http(s)` URLs go directly through `POST /api/v1/resources`.
-Local files use the safer two-step server flow: upload the file to
-`POST /api/v1/resources/temp_upload`, then add it through
-`POST /api/v1/resources` with the returned `temp_file_id`.
-
-Local paths may be absolute, relative to the OpenCode project directory, or
-`file://` URLs. Local directory upload is not supported yet.
-
-Examples:
-
-```text
-memadd path="https://example.com/spec.md" to="viking://resources/spec"
-memadd path="./docs/notes.md" parent="viking://resources/"
-memadd path="file:///home/alice/project/notes.md" reason="project notes"
-```
-
-After adding a resource, the tool also returns `GET /api/v1/observer/queue` status.
-
-### `memwrite`
-
-Write text content to a `viking://` file through `POST /api/v1/content/write`.
-
-Use this for durable notes, small project memory files, or resource text that
-should be updated directly. The default mode is `create` to avoid accidental
-overwrites. Use `append` to extend an existing file and `replace` only when the
-user explicitly wants to overwrite the file.
-
-Examples:
-
-```text
-memwrite uri="viking://user/memories/project-notes.md" content="# Decision\n\nUse PostgreSQL." wait=true
-memwrite uri="viking://resources/docs/api.md" content="\n\n## New endpoint" mode="append"
-```
-
-### `memremove`
-
-Remove a `viking://` URI through `DELETE /api/v1/fs`.
-
-This tool requires `confirm: true`. The user must explicitly confirm deletion before the agent calls it.
-
-### `memqueue`
-
-Return OpenViking observer queue status for embedding and semantic processing.
-
-### `codesearch`
-
-Search AST-supported symbol names across a confirmed ingested code repository or source subtree.
-
-Use this after you have evidence that a `viking://` URI contains supported source files.
-
-### `codeoutline`
-
-Show symbol structure for a confirmed `viking://` source file.
-
-Use this after `memglob`, `membrowse`, or `codesearch` finds an exact source file URI.
-
-### `codeexpand`
-
-Return the full source for one named symbol from a confirmed `viking://` source file.
-
-Use this after `codeoutline` or other evidence shows the symbol exists in that file.
+The proxy forwards the server's real `tools/list` response; the plugin does not maintain a separate native tool list.
 
 ## Runtime Files
 
 The plugin writes runtime files to `~/.config/opencode/openviking/` by default:
 
 - `openviking-memory.log`
-- `openviking-session-map.json`
+- `openviking-session-state.json`
 
 Set `runtime.dataDir` in config to override this directory.

package/index.mjs

@@ -3,17 +3,15 @@ import { fileURLToPath } from "url"
 import { initializeRuntime } from "./lib/runtime.mjs"
 import { createRepoContext } from "./lib/repo-context.mjs"
 import { createMemorySessionManager } from "./lib/memory-session.mjs"
-import { createCodeTools } from "./lib/code-tools.mjs"
-import { createMemoryTools } from "./lib/memory-tools.mjs"
 import { createMemoryRecall } from "./lib/memory-recall.mjs"
+import { createSessionInject } from "./lib/session-inject.mjs"
 import { createVikingUriGuard } from "./lib/viking-uri-guard.mjs"
-import { initLogger, loadConfig, log, resolveDataDir } from "./lib/utils.mjs"
+import { injectOpenVikingMcpConfig } from "./lib/mcp-config.mjs"
+import { loadConfig, resolveDataDir } from "./lib/config.mjs"
+import { initLogger, log, makeToast } from "./lib/utils.mjs"
 
 const pluginRoot = dirname(fileURLToPath(import.meta.url))
 
-/**
- * @type {import('@opencode-ai/plugin').Plugin}
- */
 export async function OpenVikingPlugin({ client, directory }) {
   const config = loadConfig(pluginRoot, directory)
   const dataDir = resolveDataDir(pluginRoot, config)
@@ -27,11 +25,17 @@ export async function OpenVikingPlugin({ client, directory }) {
   const repoContext = createRepoContext({ config })
   const sessionManager = createMemorySessionManager({ config, pluginRoot: dataDir })
   const recall = createMemoryRecall({ config })
+  const sessionInject = createSessionInject({ config, sessionManager })
   const vikingUriGuard = createVikingUriGuard()
-  const tools = createMemoryTools({ config, sessionManager, projectDirectory: directory })
-  const codeTools = createCodeTools({ config })
 
   await sessionManager.init()
+  const toast = makeToast(client)
+  if (config.legacyCredentialsUsed) {
+    log("WARN", "config", "Legacy OpenCode credential fields are still in use; run node scripts/setup.mjs to migrate to ovcli.conf", {
+      configPath: config.configPath,
+    })
+    await toast("OpenViking credentials in openviking-config.json are deprecated. Run node scripts/setup.mjs to migrate.", "warning")
+  }
 
   Promise.resolve().then(async () => {
     const ready = await initializeRuntime(config, client)
@@ -39,6 +43,11 @@ export async function OpenVikingPlugin({ client, directory }) {
   })
 
   return {
+    config: async (opencodeConfig) => {
+      const injected = injectOpenVikingMcpConfig(opencodeConfig, pluginRoot)
+      log(injected ? "INFO" : "WARN", "mcp", injected ? "Registered OpenViking MCP server" : "OpenViking MCP server was not registered")
+    },
+
     event: async ({ event }) => {
       await sessionManager.handleEvent(event)
       if (event?.type === "session.created") {
@@ -48,8 +57,6 @@ export async function OpenVikingPlugin({ client, directory }) {
 
     "tool.execute.before": vikingUriGuard,
 
-    tool: { ...tools, ...codeTools },
-
     "experimental.chat.system.transform": (_input, output) => {
       const prompt = repoContext.getRepoSystemPrompt()
       if (prompt) output.system.push(prompt)
@@ -57,6 +64,7 @@ export async function OpenVikingPlugin({ client, directory }) {
 
     "chat.message": async (input, output) => {
       try {
+        await sessionInject.injectSessionContext(input, output)
         if (!config.autoRecall?.enabled) return
         await recall.injectRelevantMemories(input, output)
       } catch (error) {
@@ -74,9 +82,9 @@ export async function OpenVikingPlugin({ client, directory }) {
       })
     },
 
-    stop: async () => {
+    dispose: async () => {
       await sessionManager.flushAll({ commit: true })
-      log("INFO", "plugin", "OpenViking plugin stopped")
+      log("INFO", "plugin", "OpenViking plugin disposed")
     },
   }
 }

package/lib/config.mjs

@@ -0,0 +1,284 @@
+import fs from "fs"
+import path from "path"
+import { homedir } from "os"
+import { resolveOpenVikingCredentials } from "./shared/credentials.mjs"
+import { resolveEffectivePeerId } from "./shared/workspace-peer.mjs"
+
+const DEFAULT_CONFIG = {
+  endpoint: "http://127.0.0.1:1933",
+  apiKey: "",
+  account: "",
+  user: "",
+  peerId: "",
+  workspacePeer: true,
+  recallPeerScope: "all",
+  enabled: true,
+  timeoutMs: 30000,
+  runtime: {
+    dataDir: "",
+  },
+  repoContext: {
+    enabled: true,
+    cacheTtlMs: 60000,
+  },
+  autoRecall: {
+    enabled: true,
+    limit: 6,
+    scoreThreshold: 0.35,
+    maxContentChars: 500,
+    preferAbstract: true,
+    tokenBudget: 2000,
+    minQueryLength: 3,
+  },
+  autoCapture: true,
+  captureMode: "semantic",
+  captureMaxLength: 24000,
+  captureAssistantTurns: true,
+  captureToolMaxChars: 2000,
+  commitTokenThreshold: 20000,
+  commitKeepRecentCount: 10,
+  profileTokenBudget: 10000,
+  resumeContextBudget: 32000,
+  noAutoInject: false,
+  bypassSession: false,
+  bypassSessionPatterns: [],
+  debug: false,
+  debugLogPath: path.join(homedir(), ".openviking", "logs", "opencode-plugin.log"),
+}
+
+function cloneDefaultConfig() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG))
+}
+
+function normalizeNumber(value, fallback, min, max) {
+  const next = Number(value)
+  if (!Number.isFinite(next)) return fallback
+  return Math.max(min, Math.min(max, next))
+}
+
+function envBool(name) {
+  const value = process.env[name]
+  if (value == null || value === "") return undefined
+  const lower = String(value).trim().toLowerCase()
+  if (lower === "0" || lower === "false" || lower === "no" || lower === "off") return false
+  if (lower === "1" || lower === "true" || lower === "yes" || lower === "on") return true
+  return undefined
+}
+
+function str(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback
+}
+
+function expandHome(value) {
+  if (!value || typeof value !== "string") return value
+  if (value === "~") return homedir()
+  if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(homedir(), value.slice(2))
+  return value
+}
+
+function readConfigFile(pluginRoot, projectDirectory) {
+  for (const configPath of getConfigPaths(pluginRoot, projectDirectory)) {
+    try {
+      if (!fs.existsSync(configPath)) continue
+      return { path: configPath, data: JSON.parse(fs.readFileSync(configPath, "utf8")) }
+    } catch (error) {
+      console.warn(`Failed to load OpenViking config from ${configPath}:`, error)
+    }
+  }
+  return { path: "", data: {} }
+}
+
+function getConfigPaths(pluginRoot, projectDirectory) {
+  const paths = []
+  if (process.env.OPENVIKING_PLUGIN_CONFIG) paths.push(expandHome(process.env.OPENVIKING_PLUGIN_CONFIG))
+  if (projectDirectory) paths.push(path.join(projectDirectory, ".opencode", "openviking-config.json"))
+  paths.push(path.join(homedir(), ".config", "opencode", "openviking-config.json"))
+  paths.push(path.join(pluginRoot, "openviking-config.json"))
+  return paths
+}
+
+function applyLegacyConnection(config, fileConfig) {
+  const hasLegacyCredentials = ["endpoint", "apiKey", "account", "user", "peerId"]
+    .some((key) => fileConfig[key] !== undefined && fileConfig[key] !== "")
+  if (!hasLegacyCredentials) return false
+
+  if (fileConfig.endpoint !== undefined) config.endpoint = fileConfig.endpoint
+  if (fileConfig.apiKey !== undefined) config.apiKey = fileConfig.apiKey
+  if (fileConfig.account !== undefined) config.account = fileConfig.account
+  if (fileConfig.user !== undefined) config.user = fileConfig.user
+  if (fileConfig.peerId !== undefined) config.peerId = fileConfig.peerId
+  return true
+}
+
+function applyBehaviorConfig(config, fileConfig = {}) {
+  if (fileConfig.enabled !== undefined) config.enabled = fileConfig.enabled !== false
+  if (fileConfig.timeoutMs !== undefined) config.timeoutMs = fileConfig.timeoutMs
+  config.runtime = {
+    ...DEFAULT_CONFIG.runtime,
+    ...(fileConfig.runtime ?? {}),
+  }
+  config.repoContext = {
+    ...DEFAULT_CONFIG.repoContext,
+    ...(fileConfig.repoContext ?? {}),
+  }
+
+  const autoRecall = fileConfig.autoRecall ?? {}
+  config.autoRecall = {
+    ...DEFAULT_CONFIG.autoRecall,
+    ...autoRecall,
+    enabled: autoRecall.enabled !== false,
+    limit: autoRecall.limit ?? fileConfig.recallLimit ?? DEFAULT_CONFIG.autoRecall.limit,
+    scoreThreshold: autoRecall.scoreThreshold ?? fileConfig.scoreThreshold ?? DEFAULT_CONFIG.autoRecall.scoreThreshold,
+    maxContentChars: autoRecall.maxContentChars ?? fileConfig.recallMaxContentChars ?? DEFAULT_CONFIG.autoRecall.maxContentChars,
+    preferAbstract: autoRecall.preferAbstract ?? fileConfig.recallPreferAbstract ?? DEFAULT_CONFIG.autoRecall.preferAbstract,
+    tokenBudget: autoRecall.tokenBudget ?? fileConfig.recallTokenBudget ?? DEFAULT_CONFIG.autoRecall.tokenBudget,
+    minQueryLength: autoRecall.minQueryLength ?? fileConfig.minQueryLength ?? DEFAULT_CONFIG.autoRecall.minQueryLength,
+  }
+
+  for (const key of [
+    "autoCapture",
+    "captureMode",
+    "captureMaxLength",
+    "captureAssistantTurns",
+    "captureToolMaxChars",
+    "commitTokenThreshold",
+    "commitKeepRecentCount",
+    "profileTokenBudget",
+    "resumeContextBudget",
+    "noAutoInject",
+    "bypassSession",
+    "bypassSessionPatterns",
+    "debug",
+    "debugLogPath",
+    "workspacePeer",
+    "recallPeerScope",
+  ]) {
+    if (fileConfig[key] !== undefined) config[key] = fileConfig[key]
+  }
+}
+
+function applyEnv(config) {
+  if (process.env.OPENVIKING_TIMEOUT_MS) config.timeoutMs = process.env.OPENVIKING_TIMEOUT_MS
+  if (process.env.OPENVIKING_AUTO_RECALL !== undefined) {
+    config.autoRecall.enabled = envBool("OPENVIKING_AUTO_RECALL") ?? config.autoRecall.enabled
+  }
+  if (process.env.OPENVIKING_RECALL_LIMIT) config.autoRecall.limit = process.env.OPENVIKING_RECALL_LIMIT
+  if (process.env.OPENVIKING_SCORE_THRESHOLD) config.autoRecall.scoreThreshold = process.env.OPENVIKING_SCORE_THRESHOLD
+  if (process.env.OPENVIKING_RECALL_MAX_CONTENT_CHARS) {
+    config.autoRecall.maxContentChars = process.env.OPENVIKING_RECALL_MAX_CONTENT_CHARS
+  }
+  if (process.env.OPENVIKING_RECALL_TOKEN_BUDGET) config.autoRecall.tokenBudget = process.env.OPENVIKING_RECALL_TOKEN_BUDGET
+  if (process.env.OPENVIKING_RECALL_PREFER_ABSTRACT !== undefined) {
+    config.autoRecall.preferAbstract = envBool("OPENVIKING_RECALL_PREFER_ABSTRACT") ?? config.autoRecall.preferAbstract
+  }
+  if (process.env.OPENVIKING_RECALL_PEER_SCOPE) config.recallPeerScope = process.env.OPENVIKING_RECALL_PEER_SCOPE
+  if (process.env.OPENVIKING_WORKSPACE_PEER !== undefined) {
+    config.workspacePeer = envBool("OPENVIKING_WORKSPACE_PEER") ?? config.workspacePeer
+  }
+  if (process.env.OPENVIKING_MIN_QUERY_LENGTH) config.autoRecall.minQueryLength = process.env.OPENVIKING_MIN_QUERY_LENGTH
+  if (process.env.OPENVIKING_AUTO_CAPTURE !== undefined) {
+    config.autoCapture = envBool("OPENVIKING_AUTO_CAPTURE") ?? config.autoCapture
+  }
+  if (process.env.OPENVIKING_CAPTURE_MODE) config.captureMode = process.env.OPENVIKING_CAPTURE_MODE
+  if (process.env.OPENVIKING_CAPTURE_MAX_LENGTH) config.captureMaxLength = process.env.OPENVIKING_CAPTURE_MAX_LENGTH
+  if (process.env.OPENVIKING_CAPTURE_ASSISTANT_TURNS !== undefined) {
+    config.captureAssistantTurns = envBool("OPENVIKING_CAPTURE_ASSISTANT_TURNS") ?? config.captureAssistantTurns
+  }
+  if (process.env.OPENVIKING_CAPTURE_TOOL_MAX_CHARS) {
+    config.captureToolMaxChars = process.env.OPENVIKING_CAPTURE_TOOL_MAX_CHARS
+  }
+  if (process.env.OPENVIKING_COMMIT_TOKEN_THRESHOLD) {
+    config.commitTokenThreshold = process.env.OPENVIKING_COMMIT_TOKEN_THRESHOLD
+  }
+  if (process.env.OPENVIKING_COMMIT_KEEP_RECENT_COUNT) {
+    config.commitKeepRecentCount = process.env.OPENVIKING_COMMIT_KEEP_RECENT_COUNT
+  }
+  if (process.env.OPENVIKING_PROFILE_TOKEN_BUDGET) config.profileTokenBudget = process.env.OPENVIKING_PROFILE_TOKEN_BUDGET
+  if (process.env.OPENVIKING_RESUME_CONTEXT_BUDGET) config.resumeContextBudget = process.env.OPENVIKING_RESUME_CONTEXT_BUDGET
+  if (process.env.OPENVIKING_NO_AUTO_INJECT !== undefined) {
+    config.noAutoInject = envBool("OPENVIKING_NO_AUTO_INJECT") ?? config.noAutoInject
+  }
+  if (process.env.OPENVIKING_BYPASS_SESSION !== undefined) {
+    config.bypassSession = envBool("OPENVIKING_BYPASS_SESSION") ?? config.bypassSession
+  }
+  if (process.env.OPENVIKING_BYPASS_SESSION_PATTERNS) {
+    config.bypassSessionPatterns = process.env.OPENVIKING_BYPASS_SESSION_PATTERNS
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+  if (process.env.OPENVIKING_DEBUG !== undefined) config.debug = envBool("OPENVIKING_DEBUG") ?? config.debug
+  if (process.env.OPENVIKING_DEBUG_LOG) config.debugLogPath = process.env.OPENVIKING_DEBUG_LOG
+}
+
+function normalizeConfig(config) {
+  config.endpoint = str(config.endpoint, DEFAULT_CONFIG.endpoint).replace(/\/+$/, "")
+  config.baseUrl = config.endpoint
+  config.accountId = config.account
+  config.userId = config.user
+  config.timeoutMs = normalizeNumber(config.timeoutMs, DEFAULT_CONFIG.timeoutMs, 1000, 300000)
+  config.repoContext.cacheTtlMs = normalizeNumber(
+    config.repoContext.cacheTtlMs,
+    DEFAULT_CONFIG.repoContext.cacheTtlMs,
+    1000,
+    60 * 60 * 1000,
+  )
+  config.autoRecall.limit = Math.max(1, Math.min(50, Math.round(Number(config.autoRecall.limit) || 6)))
+  config.autoRecall.scoreThreshold = Math.max(0, Math.min(1, Number(config.autoRecall.scoreThreshold) || 0))
+  config.autoRecall.maxContentChars = Math.max(100, Math.min(5000, Math.round(Number(config.autoRecall.maxContentChars) || 500)))
+  config.autoRecall.tokenBudget = Math.max(200, Math.min(50000, Math.round(Number(config.autoRecall.tokenBudget) || 2000)))
+  config.autoRecall.minQueryLength = Math.max(1, Math.min(64, Math.round(Number(config.autoRecall.minQueryLength) || 3)))
+  config.captureMode = config.captureMode === "keyword" ? "keyword" : "semantic"
+  config.recallPeerScope = config.recallPeerScope === "actor" ? "actor" : "all"
+  config.captureMaxLength = Math.max(200, Math.min(100000, Math.round(Number(config.captureMaxLength) || 24000)))
+  config.captureToolMaxChars = Math.max(200, Math.min(20000, Math.round(Number(config.captureToolMaxChars) || 2000)))
+  config.commitTokenThreshold = Math.max(1000, Math.round(Number(config.commitTokenThreshold) || 20000))
+  config.commitKeepRecentCount = Math.max(0, Math.round(Number(config.commitKeepRecentCount) || 10))
+  config.profileTokenBudget = Math.max(500, Math.round(Number(config.profileTokenBudget) || 10000))
+  config.resumeContextBudget = Math.max(1024, Math.round(Number(config.resumeContextBudget) || 32000))
+  if (!Array.isArray(config.bypassSessionPatterns)) config.bypassSessionPatterns = []
+
+  config.recallLimit = config.autoRecall.limit
+  config.scoreThreshold = config.autoRecall.scoreThreshold
+  config.recallMaxContentChars = config.autoRecall.maxContentChars
+  config.recallPreferAbstract = config.autoRecall.preferAbstract !== false
+  config.recallTokenBudget = config.autoRecall.tokenBudget
+  config.minQueryLength = config.autoRecall.minQueryLength
+  return config
+}
+
+export function loadConfig(pluginRoot, projectDirectory) {
+  const config = cloneDefaultConfig()
+  const { path: configPath, data: fileConfig } = readConfigFile(pluginRoot, projectDirectory)
+  applyBehaviorConfig(config, fileConfig)
+
+  const creds = resolveOpenVikingCredentials()
+  config.endpoint = creds.baseUrl
+  config.apiKey = creds.apiKey
+  config.account = creds.account
+  config.user = creds.user
+  config.peerId = creds.peerId
+  config.mcpUrl = creds.mcpUrl
+  config.credentialSource = creds.credentialSource
+  config.credentialPath = creds.cliPath || creds.ovPath || ""
+
+  const mayUseLegacyCredentials = creds.credentialSource !== "env" &&
+    creds.credentialSource !== "ovcli" &&
+    !creds.apiKey &&
+    !creds.account &&
+    !creds.user &&
+    !creds.peerId
+  const legacyUsed = mayUseLegacyCredentials ? applyLegacyConnection(config, fileConfig) : false
+  applyEnv(config)
+  config.configPath = configPath
+  config.legacyCredentialsUsed = legacyUsed && creds.credentialSource !== "env"
+  const normalized = normalizeConfig(config)
+  normalized.effectivePeer = resolveEffectivePeerId({ cfg: normalized, cwd: projectDirectory })
+  return normalized
+}
+
+export function resolveDataDir(pluginRoot, config) {
+  const configured = config.runtime?.dataDir
+  if (configured) return expandHome(configured)
+  return path.join(homedir(), ".config", "opencode", "openviking")
+}

package/lib/mcp-config.mjs

@@ -0,0 +1,21 @@
+import { resolve as resolvePath } from "node:path"
+
+export const OPENCODE_MCP_NAME = "openviking"
+
+export function createOpenVikingMcpConfig(pluginRoot) {
+  return {
+    type: "local",
+    command: ["node", resolvePath(pluginRoot, "servers", "mcp-proxy.mjs")],
+    enabled: true,
+    timeout: 15000,
+  }
+}
+
+export function injectOpenVikingMcpConfig(config, pluginRoot) {
+  if (!config || typeof config !== "object") return false
+  config.mcp = config.mcp && typeof config.mcp === "object" ? config.mcp : {}
+  const current = config.mcp[OPENCODE_MCP_NAME]
+  if (current?.enabled === false) return false
+  config.mcp[OPENCODE_MCP_NAME] = createOpenVikingMcpConfig(pluginRoot)
+  return true
+}