@openviking/opencode-plugin 0.2.3 → 2026.9.9-1

package/lib/shared/workspace-identity.mjs

@@ -0,0 +1,334 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Workspace identity: where the workspace root is, and what git calls it.
+ *
+ * Every hook is a fresh Node process and this runs on prompt-level paths, so
+ * the derivation is pure filesystem work — no `git` subprocess. That keeps it
+ * inside the tightest hook budget (Codex allows SessionEnd 3s against
+ * SessionStart's 70s), and it keeps working where git is absent from PATH or
+ * would refuse the repo over dubious ownership.
+ *
+ * The result is cached per cwd under the state dir so the several hooks of one
+ * turn pay for the walk once.
+ */
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, parse, resolve, sep } from "node:path";
+
+// The workspace config file names live here, and `workspace-config.mjs`
+// re-exports them: the walk below needs the filenames to recognise a directory
+// someone marked as a workspace, and it must not pull in the config layer to
+// learn them.
+export const CONFIG_DIR_NAME = ".openviking";
+export const TEAM_FILE = "config.json";
+export const LOCAL_FILE = "config.local.json";
+
+const IDENTITY_CACHE_TTL_MS = 60_000;
+// 255 is the AGFS path-segment limit; stopping well short leaves room for the
+// hash suffix and for anything that later prefixes a peer id.
+const MAX_PEER_ID_LENGTH = 100;
+
+export function stateDir(env = process.env) {
+  const explicit = String(env.OPENVIKING_STATE_DIR || "").trim();
+  if (explicit) return explicit;
+  const home = String(env.OPENVIKING_HOME || "").trim();
+  const base = home ? home.replace(/^~(?=$|\/)/, homedir()) : join(homedir(), ".openviking");
+  return join(base, "state");
+}
+
+function shortHash(value) {
+  return createHash("sha256").update(String(value)).digest("hex").slice(0, 12);
+}
+
+/**
+ * Legacy peer sanitation: one byte in, one byte out, no collapsing and no
+ * trimming, so a leading `/` still becomes a leading `-`. Kept byte-exact
+ * because `peer.source: "cwd"` and the legacy id that dual-read recomputes both
+ * depend on it — do not "improve" it.
+ */
+export function legacySanitize(value) {
+  return String(value || "").replace(/[^A-Za-z0-9]/g, "-");
+}
+
+/**
+ * Readable sanitation for values that were never path-shaped — a normalized
+ * remote, a directory name. Mirrors the server's own `_sanitize_component`
+ * (`openviking/ingest/peer.py:32`) so both languages agree on the id, then
+ * enforces what `validate_identifier_part` additionally requires.
+ */
+export function sanitizePeerId(value) {
+  const raw = String(value || "").trim();
+  let cleaned = raw.replace(/[^a-zA-Z0-9_.@-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+  if (!cleaned) return "";
+  // The server accepts at most one `@` in an identifier part.
+  const at = cleaned.indexOf("@");
+  if (at !== -1) cleaned = cleaned.slice(0, at + 1) + cleaned.slice(at + 1).replace(/@/g, "-");
+  // `ext-` is the server's namespace for base64-encoded external identities,
+  // and `__self` its operation-target sentinel. Neither is ours to occupy.
+  if (cleaned.startsWith("ext-")) cleaned = `x-${cleaned}`;
+  if (cleaned === "__self") cleaned = "self";
+  if (cleaned === "." || cleaned === "..") return "";
+  if (cleaned.length > MAX_PEER_ID_LENGTH) {
+    cleaned = `${cleaned.slice(0, MAX_PEER_ID_LENGTH - 13).replace(/[-.]+$/, "")}-${shortHash(raw)}`;
+  }
+  return cleaned;
+}
+
+/**
+ * Normalize a remote URL to `host/path`, lowercased.
+ *
+ * Both spellings of the same repo converge, and userinfo is dropped — so a
+ * remote with an embedded token cannot leak it into a peer id. The cost of
+ * case folding is that two repos differing only in case share one namespace on
+ * the rare case-sensitive forge.
+ */
+export function normalizeGitRemote(url) {
+  const raw = String(url || "").trim();
+  if (!raw) return "";
+
+  // `C:\src\repo` and `C:/src/repo` are one machine's directory, not a shared
+  // identity — and the scp pattern would happily read the drive as a host.
+  if (/^[A-Za-z]:[\\/]/.test(raw)) return "";
+
+  let host = "";
+  let path = "";
+  const scp = /^(?:[^@/\\]+@)?([^:/\\]+):(?!\/)(.+)$/.exec(raw);
+  if (scp && !/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    let parsed;
+    try {
+      parsed = new URL(raw);
+    } catch {
+      return "";
+    }
+    // A local clone has no stable shared identity — fall through to the path
+    // rules instead of minting one from `file://` or a bare directory.
+    if (parsed.protocol === "file:" || !parsed.hostname) return "";
+    host = parsed.hostname;
+    path = parsed.pathname;
+  }
+
+  host = host.toLowerCase().replace(/^\[|\]$/g, "");
+  path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "").toLowerCase();
+  if (!host || !path) return "";
+  return `${host}/${path}`;
+}
+
+function readFileOrEmpty(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Read `[remote "origin"] url` out of a git config with a minimal INI parse.
+ *
+ * `include` / `includeIf` are deliberately not followed: resolving them means
+ * more filesystem walking for a value the fallback chain already covers, so an
+ * unreadable remote just falls through to the next template.
+ */
+export function readGitRemoteUrl(commonDir, remote = "origin") {
+  const text = readFileOrEmpty(join(commonDir, "config"));
+  if (!text) return "";
+
+  let inSection = false;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
+    const section = /^\[([^\]]+)\]/.exec(trimmed);
+    if (section) {
+      const header = section[1].trim();
+      // git folds section and key names to lower case but keeps a quoted
+      // subsection exact, so `[Remote "origin"]` is the same section and
+      // `[remote "Origin"]` is not.
+      const quoted = /^remote\s+"(.*)"$/i.exec(header);
+      inSection = Boolean(quoted && quoted[1] === remote);
+      continue;
+    }
+    if (!inSection) continue;
+    const pair = /^url\s*=\s*(.*)$/i.exec(trimmed);
+    // git treats an unquoted `#` or `;` as starting a comment anywhere on the
+    // line, so a trailing note is not part of the URL.
+    if (pair) return pair[1].split(/[#;]/)[0].trim().replace(/^["']|["']$/g, "");
+  }
+  return "";
+}
+
+function resolveGitDir(root) {
+  const dotGit = join(root, ".git");
+  let stat;
+  try {
+    stat = statSync(dotGit);
+  } catch {
+    return null;
+  }
+  if (stat.isDirectory()) return { gitDir: dotGit, commonDir: dotGit, kind: "repo" };
+  if (!stat.isFile()) return null;
+
+  const pointer = /^gitdir:\s*(.+)$/m.exec(readFileOrEmpty(dotGit));
+  if (!pointer) return null;
+  const gitDir = resolve(root, pointer[1].trim());
+
+  // `commondir` is the worktree signal, so it is read first — a repository
+  // that merely lives under a directory called `modules` is not a submodule.
+  const commonRef = readFileOrEmpty(join(gitDir, "commondir")).trim();
+  const commonDir = commonRef
+    ? (isAbsolute(commonRef) ? commonRef : resolve(gitDir, commonRef))
+    : gitDir;
+
+  // A submodule keeps its own remote under the superproject's
+  // `.git/modules/<name>`; converging it onto the superproject would merge two
+  // repositories that release, and are reviewed, separately. Only the segment
+  // right after a `.git` directory means that, which is also why a worktree of
+  // a submodule resolves here through its own commondir.
+  const kind = /[/\\]\.git[/\\]modules[/\\]/.test(`${commonDir}${sep}`)
+    ? "submodule"
+    : (commonRef ? "worktree" : "repo");
+  return { gitDir, commonDir, kind };
+}
+
+/** A directory the user made a workspace on purpose, by giving it a config file. */
+function hasWorkspaceMarker(dir) {
+  for (const name of [TEAM_FILE, LOCAL_FILE]) {
+    try {
+      if (statSync(join(dir, CONFIG_DIR_NAME, name)).isFile()) return true;
+    } catch { /* not marked here */ }
+  }
+  return false;
+}
+
+const NO_ROOT = Object.freeze({ root: "", rootKind: "", git: null, gitRoot: "" });
+
+/**
+ * Walk up from `cwd` to the nearest workspace root.
+ *
+ * A workspace is a git repository, or a directory someone marked as one by
+ * creating `.openviking/config.json` (or `config.local.json`) in it. Nearest
+ * wins. Above a marked directory the walk continues to the enclosing
+ * repository, if any, so the git-shaped variables still resolve there.
+ * Anything else — a scratch folder, a download, an app's per-task directory —
+ * is not a workspace and gets no peer of its own.
+ *
+ * `$HOME` and the filesystem root are never workspace roots: a stray `.git`
+ * in either would silently make every unrelated directory one workspace.
+ */
+export function findWorkspaceRoot(cwd, env = process.env) {
+  const start = String(cwd || "").trim();
+  if (!start) return NO_ROOT;
+
+  let absolute;
+  try {
+    // A relative `start` makes `resolve` read process.cwd(), which throws when
+    // the directory is gone — the very case the catch below is meant to cover.
+    absolute = resolve(start);
+  } catch {
+    return NO_ROOT;
+  }
+
+  // `current` and `stopAt` are compared as strings, so they must be
+  // canonicalized together. A `$HOME` reached through a symlink plus an
+  // unresolvable cwd would otherwise walk straight past the guard.
+  const home = String(env.HOME || "").trim() || homedir();
+  let current;
+  let stopAt;
+  try {
+    current = realpathSync(absolute);
+    stopAt = realpathSync(home);
+  } catch {
+    current = absolute;
+    stopAt = home;
+  }
+  const filesystemRoot = parse(current).root;
+  if (current === stopAt || current === filesystemRoot) return NO_ROOT;
+
+  let root = "";
+  let rootKind = "";
+  while (current && current !== filesystemRoot && current !== stopAt) {
+    const git = resolveGitDir(current);
+    if (git) return { root: root || current, rootKind: rootKind || "git", git, gitRoot: current };
+    if (!root && hasWorkspaceMarker(current)) {
+      root = current;
+      rootKind = "config";
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return root ? { root, rootKind, git: null, gitRoot: "" } : NO_ROOT;
+}
+
+function cachePath(cwd, env) {
+  return join(stateDir(env), `ws-identity-${shortHash(cwd)}.json`);
+}
+
+function readCache(path, now) {
+  try {
+    const cached = JSON.parse(readFileSync(path, "utf-8"));
+    // Bounded on both sides: an entry stamped in the future — a clock that ran
+    // fast, or `Infinity` — would otherwise pin a stale identity indefinitely.
+    if (typeof cached?.ts !== "number" || cached.ts > now || now - cached.ts > IDENTITY_CACHE_TTL_MS) return null;
+    const identity = cached.identity;
+    if (identity && typeof identity === "object" && identity.vars && typeof identity.vars === "object") {
+      return identity;
+    }
+  } catch { /* a cold or corrupt cache just costs one walk */ }
+  return null;
+}
+
+function writeCache(path, identity, now) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ ts: now, identity }), { mode: 0o600 });
+    renameSync(tmp, path);
+  } catch { /* best effort */ }
+}
+
+/**
+ * Everything the peer templates can substitute, for one cwd.
+ *
+ * `git_remote` and `dir` are already sanitized; `git_root` and `cwd` carry the
+ * legacy byte-for-byte rule, because they are the two that must reproduce a
+ * peer minted before any of this existed.
+ */
+export function resolveWorkspaceIdentity({ cwd = "", env = process.env, cache = true, now = Date.now() } = {}) {
+  const key = String(cwd || "");
+  const path = cachePath(key, env);
+  if (cache) {
+    const hit = readCache(path, now);
+    if (hit) return hit;
+  }
+
+  const { root, rootKind, git, gitRoot } = findWorkspaceRoot(key, env);
+  // Only the normalized form is kept. The raw URL may carry a token, and this
+  // file outlives the process — writing it here would undo the care
+  // `normalizeGitRemote` takes to drop userinfo.
+  const remote = git ? normalizeGitRemote(readGitRemoteUrl(git.commonDir)) : "";
+  const identity = {
+    cwd: key,
+    root,
+    rootKind,
+    isGit: Boolean(git),
+    gitKind: git?.kind || "",
+    gitCommonDir: git?.commonDir || "",
+    gitRoot,
+    remote,
+    vars: {
+      git_remote: sanitizePeerId(remote),
+      // The enclosing repository's root, which is not the workspace root when a
+      // marker file below it won. Empty outside a repository, so the `git`
+      // preset resolves to nothing there rather than to a bare path.
+      git_root: git ? legacySanitize(gitRoot) : "",
+      cwd: legacySanitize(key),
+      dir: root ? sanitizePeerId(root.split(/[/\\]/).filter(Boolean).pop() || "") : "",
+    },
+  };
+  if (cache) writeCache(path, identity, now);
+  return identity;
+}

package/lib/shared/workspace-peer.mjs

@@ -1,16 +1,134 @@
 // GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Which peer a workspace writes its memories under.
+ *
+ * The peer used to be the working directory with every non-alphanumeric byte
+ * turned into a dash, which made the identity an accident of where the
+ * repository happened to sit: a clone on another machine, a rename, a worktree
+ * or simply `cd examples/` each minted a separate, empty namespace. The default
+ * is now git's own idea of the repository, so one project keeps one memory
+ * wherever it is checked out.
+ *
+ * `peer.source` decides the rule. Presets cover the three answers most people
+ * want; a template — or a list of templates tried in order — covers the rest.
+ * The old behaviour is still one word away, byte for byte.
+ */
+
+import { legacySanitize, resolveWorkspaceIdentity, sanitizePeerId } from "./workspace-identity.mjs";
+
+/**
+ * `git` is the default, and it resolves only inside a repository: the remote
+ * first, because that is the one name every clone agrees on, then the
+ * repository root for a repo that has none. Anywhere else it resolves to
+ * nothing and no peer is sent — a scratch folder or an app's per-task
+ * directory would otherwise mint a fresh, empty namespace each time, so those
+ * memories go to the user-level space instead. Naming such a directory is what
+ * `peer.id` is for, and deriving one from a bare path is what `cwd` is for;
+ * both are opt-in.
+ *
+ * No preset adds a prefix. A path-derived id starts with `-` on POSIX, so it
+ * cannot collide with a remote-derived one; anyone who wants a prefix writes
+ * their own template.
+ */
+export const PEER_SOURCE_PRESETS = {
+  git: ["{git_remote}", "{git_root}"],
+  cwd: ["{cwd}"],
+  none: [],
+};
+
+export const DEFAULT_PEER_SOURCE = "git";
+
+const VARIABLE_RE = /\{([a-z_]+)\}/g;
+
 export function deriveWorkspacePeerId(cwd) {
-  return String(cwd || "").replace(/[^A-Za-z0-9]/g, "-");
+  return legacySanitize(cwd);
 }
 
-export function resolveEffectivePeerId({ cfg = {}, cwd = "" } = {}) {
+/**
+ * Normalize `peer.source` — a preset name, a template, or a list — to templates.
+ *
+ * A bare string with no `{` is a misspelled preset, not a template: `Git` or
+ * `gti` would otherwise become a peer literally named `Git`, quietly stranding
+ * the workspace's memories in a namespace nobody meant to create. Such a value
+ * warns and falls back to the default chain. An array is left alone — writing a
+ * list is explicit enough to mean the constant it contains.
+ */
+export function peerSourceTemplates(source, onWarn = null) {
+  if (Array.isArray(source)) return source.map(String).filter(Boolean);
+  const raw = String(source ?? "").trim();
+  if (!raw) return PEER_SOURCE_PRESETS[DEFAULT_PEER_SOURCE];
+  if (Object.hasOwn(PEER_SOURCE_PRESETS, raw)) return PEER_SOURCE_PRESETS[raw];
+  if (raw.includes("{")) return [raw];
+
+  const message = `OpenViking: ignored peer.source ${JSON.stringify(raw)}: it is neither a preset `
+    + `(${Object.keys(PEER_SOURCE_PRESETS).join(", ")}) nor a template such as "team-{dir}". `
+    + `Falling back to ${DEFAULT_PEER_SOURCE}.`;
+  if (typeof onWarn === "function") onWarn(message);
+  else process.stderr.write(`${message}\n`);
+  return PEER_SOURCE_PRESETS[DEFAULT_PEER_SOURCE];
+}
+
+/**
+ * Substitute one template, or return "" when any variable it names is empty.
+ *
+ * All-or-nothing on purpose: a half-resolved template like `git-` would be a
+ * silently shared identity, so an empty variable falls through to the next
+ * template instead.
+ */
+export function renderPeerTemplate(template, vars) {
+  const text = String(template || "");
+  if (!text) return "";
+  let empty = false;
+  const rendered = text.replace(VARIABLE_RE, (match, name) => {
+    if (!Object.hasOwn(vars, name)) {
+      empty = true;
+      return "";
+    }
+    const value = String(vars[name] ?? "");
+    if (!value) empty = true;
+    return value;
+  });
+  return empty ? "" : rendered;
+}
+
+/**
+ * The peer this process should send, and where it came from.
+ *
+ * `source` keeps its three values — call sites compare it against the literal
+ * `"workspace"` to decide whether a session pin may be reused — while `origin`
+ * names the template that actually produced the id, and `legacyPeerId` carries
+ * the pre-git id whenever it differs, so recall can still reach memories
+ * written under it.
+ */
+export function resolveEffectivePeerId({ cfg = {}, cwd = "", identity = null, env = process.env, onWarn = null } = {}) {
   const explicit = String(cfg.peerId || "").trim();
-  if (explicit) return { peerId: explicit, source: "explicit" };
+  if (explicit) return { peerId: explicit, source: "explicit", origin: "explicit", legacyPeerId: "" };
 
-  if (cfg.workspacePeer !== false) {
-    const peerId = deriveWorkspacePeerId(cwd);
-    if (peerId) return { peerId, source: "workspace" };
-  }
+  // `OPENVIKING_WORKSPACE_PEER=0` predates `peer.source` and still means "none".
+  if (cfg.workspacePeer === false) return { peerId: "", source: "none", origin: "disabled", legacyPeerId: "" };
+
+  const templates = peerSourceTemplates(cfg.peerSource, onWarn);
+  if (!templates.length) return { peerId: "", source: "none", origin: "none", legacyPeerId: "" };
 
-  return { peerId: "", source: "none" };
+  // `harness` is composed here rather than in the identity, whose result is
+  // cached on disk under a cwd-only key — two harnesses in one directory would
+  // otherwise read each other's peer back out of that cache.
+  const vars = {
+    ...((identity || resolveWorkspaceIdentity({ cwd, env })).vars || {}),
+    harness: sanitizePeerId(cfg.harness || cfg.clientId || ""),
+  };
+  const legacyPeerId = deriveWorkspacePeerId(cwd);
+  for (const template of templates) {
+    const peerId = renderPeerTemplate(template, vars);
+    if (!peerId) continue;
+    return {
+      peerId,
+      source: "workspace",
+      origin: template,
+      legacyPeerId: peerId === legacyPeerId ? "" : legacyPeerId,
+    };
+  }
+  // No peer, but the pre-git id is still what earlier sessions in this
+  // directory wrote under, so recall keeps reaching it.
+  return { peerId: "", source: "none", origin: "unresolved", legacyPeerId };
 }

package/lib/utils.mjs

@@ -68,6 +68,10 @@ export function effectivePeerId(config) {
   return String(config.effectivePeer?.peerId || config.peerId || "").trim() || null
 }
 
+function responseTraceId(payload) {
+  return payload?.result?.trace_id || payload?.error?.trace_id || payload?.trace_id || undefined
+}
+
 export async function fetchJSON(config, endpoint, init = {}, options = {}) {
   const url = `${normalizeEndpoint(config.endpoint)}${endpoint}`
   const headers = makeAuthHeaders(
@@ -85,14 +89,16 @@ export async function fetchJSON(config, endpoint, init = {}, options = {}) {
     })
     const text = await response.text()
     const payload = text ? parseJsonOrText(text) : {}
+    const traceId = responseTraceId(payload)
     if (!response.ok || payload?.status === "error") {
       return {
         ok: false,
         status: response.status,
         error: payload?.error || payload?.message || { message: `HTTP ${response.status}` },
+        traceId,
       }
     }
-    return { ok: true, status: response.status, result: payload?.result ?? payload }
+    return { ok: true, status: response.status, result: payload?.result ?? payload, traceId }
   } catch (error) {
     return { ok: false, status: 0, error: { message: error?.message ?? String(error) } }
   } finally {
@@ -213,6 +219,7 @@ function makeAuthHeaders(config, headers = {}, actorPeerId = "") {
   if (config.user) result["X-OpenViking-User"] = config.user
   const peerId = String(actorPeerId || "").trim()
   if (peerId) result["X-OpenViking-Actor-Peer"] = peerId
+  if (config.userAgent) result["User-Agent"] = config.userAgent
   return result
 }
 

package/lib/viking-uri-guard.mjs

@@ -4,7 +4,7 @@ import { buildGuardMessage, findVikingUri, normalizeToolName } from "./shared/ur
 const FILESYSTEM_TOOL_HINTS = {
   read: {
     tool: "openviking_read",
-    example: (uri) => `openviking_read(uri="${uri}")`,
+    example: (uri) => `openviking_read(uris=["${uri}"])`,
   },
   glob: {
     tool: "openviking_glob",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "0.2.3",
+  "version": "2026.9.9-1",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -43,5 +43,6 @@
     "rag",
     "code-search"
   ],
-  "license": "Apache-2.0"
+  "license": "Apache-2.0",
+  "openvikingSourceCommit": "708dba60bd2484a9ecb69da27383b5203d8daee2"
 }

package/servers/mcp-proxy.mjs

@@ -13,55 +13,32 @@ import { join, resolve as resolvePath } from "node:path"
 import { fileURLToPath } from "node:url"
 import { loadConfig } from "../lib/config.mjs"
 import { createLogger } from "../lib/shared/debug-log.mjs"
+import { buildMcpProxyConfig, resolveMcpActorPeerId } from "../lib/shared/mcp-proxy-config.mjs"
 import { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
-import { resolveEffectivePeerId } from "../lib/shared/workspace-peer.mjs"
 
 export { createOpenVikingMcpProxy } from "../lib/shared/mcp-proxy-core.mjs"
 
-const DEFAULT_TIMEOUT_MS = 15000
-
-function trimSlash(value) {
-  return String(value || "").replace(/\/+$/, "")
-}
-
-function normalizePath(value) {
-  const raw = String(value || "").trim()
-  if (!raw) return ""
-  if (raw === "~") return homedir()
-  if (raw.startsWith("~/")) return resolvePath(join(homedir(), raw.slice(2)))
-  return resolvePath(raw)
-}
-
-function uniq(values) {
-  return [...new Set(values.filter(Boolean))]
-}
-
 function readProxyConfig() {
   const cfg = loadConfig(resolvePath(fileURLToPath(import.meta.url), "..", ".."))
-  const effectivePeer = resolveEffectivePeerId({ cfg, cwd: process.cwd() })
-  const mcpUrl = cfg.mcpUrl || `${trimSlash(cfg.endpoint)}/mcp`
-  return {
-    mcpUrl,
-    apiKey: cfg.apiKey || "",
-    account: cfg.account || "",
-    user: cfg.user || "",
-    peerId: effectivePeer.peerId,
-    timeoutMs: Math.max(1000, Number(cfg.timeoutMs) || DEFAULT_TIMEOUT_MS),
-    debug: cfg.debug === true,
+  return buildMcpProxyConfig({
+    baseUrl: cfg.endpoint,
+    mcpUrl: cfg.mcpUrl,
+    apiKey: cfg.apiKey,
+    account: cfg.account,
+    user: cfg.user,
+    peerId: resolveMcpActorPeerId(cfg),
+    userAgent: cfg.userAgent,
+    timeoutMs: cfg.timeoutMs,
+    debug: cfg.debug,
     debugLogPath: cfg.debugLogPath,
-    credentialSource: cfg.credentialSource || "auto",
-    credentialPath: cfg.credentialPath || cfg.configPath || "",
-    watchedPaths: uniq([
+    credentialSource: cfg.credentialSource,
+    credentialPath: cfg.credentialPath || cfg.configPath,
+    watchedPaths: [
       cfg.credentialPath,
       cfg.configPath,
-      normalizePath(process.env.OPENVIKING_CLI_CONFIG_FILE),
-      normalizePath(process.env.OPENVIKING_CONFIG_FILE),
-      normalizePath(process.env.OPENVIKING_PLUGIN_CONFIG),
-      join(homedir(), ".openviking", "ovcli.conf"),
-      join(homedir(), ".openviking", "ov.conf"),
       join(homedir(), ".config", "opencode", "openviking-config.json"),
-    ]),
-  }
+    ],
+  })
 }
 
 if (process.argv[1] && fileURLToPath(import.meta.url) === resolvePath(process.argv[1])) {

package/servers/mcp-proxy.test.mjs

@@ -56,6 +56,7 @@ function makeProxy(url) {
       account: "acct",
       user: "user",
       peerId: "peer",
+      userAgent: "openviking-memory-opencode/9.9.9",
       timeoutMs: 5000,
       debug: false,
       debugLogPath: "",
@@ -81,6 +82,7 @@ test("OpenCode MCP proxy forwards initialize with auth and identity headers", as
     assert.equal(entry.headers["x-openviking-account"], "acct")
     assert.equal(entry.headers["x-openviking-user"], "user")
     assert.equal(entry.headers["x-openviking-actor-peer"], "peer")
+    assert.equal(entry.headers["user-agent"], "openviking-memory-opencode/9.9.9")
     res.writeHead(200, {
       "content-type": "text/event-stream",
       "mcp-session-id": "sid-oc",