@openviking/opencode-plugin 0.2.4 → 2026.9.9-1

package/lib/shared/capture-utils.mjs

@@ -1,4 +1,6 @@
 // GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+import { applyInputFilters, compileInputFilters } from "./input-filters.mjs";
+
 const TEXT_BLOCK_TYPES = new Set(["text", "input_text", "output_text"]);
 const TOOL_CALL_TYPES = new Set([
   "tool_call",
@@ -17,6 +19,11 @@ const TOOL_RESULT_TYPES = new Set([
   "functioncalloutput",
 ]);
 
+// Tool output is reported verbatim; the server owns truncation via
+// tool_output_externalization (threshold_chars, default 20000). This cap only
+// guards against pathological payloads.
+const DEFAULT_TOOL_MAX_CHARS = 1000000;
+
 const ACK_RE = /^(?:ok|okay|k|yes|yep|no|nope|thanks|thank you|thx|done|收到|好的|好|嗯|可以|继续|不用|不需要|没了|好了)[.!?。！？\s]*$/i;
 const SLASH_COMMAND_RE = /^\/[a-z0-9_-]{1,64}\b/i;
 const METADATA_KEYS = [
@@ -97,6 +104,7 @@ function toolName(block) {
     block?.name ||
     block?.tool_name ||
     block?.toolName ||
+    block?.tool ||
     block?.function?.name ||
     block?.call?.name ||
     "",
@@ -107,6 +115,7 @@ function toolPayload(block, kind) {
   if (!block || typeof block !== "object") return "";
   if (kind === "call") {
     return block.input ??
+      block.state?.input ??
       block.arguments ??
       block.args ??
       block.params ??
@@ -117,8 +126,10 @@ function toolPayload(block, kind) {
       "";
   }
   return block.output ??
+    block.state?.output ??
     block.result ??
     block.error ??
+    block.state?.error ??
     block.data ??
     block.content ??
     block.text ??
@@ -129,6 +140,7 @@ function toolId(block) {
   return oneLine(
     block?.call_id ||
     block?.callId ||
+    block?.callID ||
     block?.tool_call_id ||
     block?.toolCallId ||
     block?.tool_use_id ||
@@ -142,12 +154,20 @@ function toolId(block) {
 
 function toolStatus(block, kind) {
   if (kind === "call") return "running";
-  if (block?.is_error || block?.error) return "error";
-  const status = oneLine(block?.status || "");
+  if (block?.is_error || block?.isError || block?.state?.isError || block?.error || block?.state?.error) return "error";
+  const status = oneLine(block?.status || block?.state?.status || "");
   return status || "completed";
 }
 
-function buildToolPart(block, kind, { toolMaxChars = 2000, toolNameById = {} } = {}) {
+function setToolInput(part, payload) {
+  const input = parseMaybeJson(payload);
+  if (input === "" || input == null) return;
+  part.tool_input = typeof input === "object" && !Array.isArray(input)
+    ? input
+    : { value: input };
+}
+
+function buildToolPart(block, kind, { toolMaxChars = DEFAULT_TOOL_MAX_CHARS, toolNameById = {} } = {}) {
   const id = toolId(block);
   const name = toolName(block) || (id ? toolNameById[id] : "");
   const payload = toolPayload(block, kind);
@@ -158,13 +178,11 @@ function buildToolPart(block, kind, { toolMaxChars = 2000, toolNameById = {} } =
     tool_status: toolStatus(block, kind),
   };
   if (kind === "call") {
-    const input = parseMaybeJson(payload);
-    if (input !== "" && input != null) {
-      part.tool_input = typeof input === "object" && !Array.isArray(input)
-        ? input
-        : { value: input };
-    }
+    setToolInput(part, payload);
   } else {
+    if (block?.state?.input !== undefined) {
+      setToolInput(part, block.state.input);
+    }
     part.tool_output = stringifyCompact(payload, toolMaxChars);
   }
   return part;
@@ -201,7 +219,7 @@ function blockToText(block, options) {
 }
 
 export function extractTextFromContent(content, options = {}) {
-  const opts = { toolMaxChars: 2000, ...options };
+  const opts = { toolMaxChars: DEFAULT_TOOL_MAX_CHARS, ...options };
   if (!content) return "";
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -221,7 +239,7 @@ export function extractTextFromPayload(payload, options = {}) {
   const chunks = [];
   const directType = normalizeType(payload.type || payload.kind || payload.role);
   if (TOOL_RESULT_TYPES.has(directType) || directType === "tool" || TOOL_CALL_TYPES.has(directType)) {
-    const direct = blockToText(payload, { toolMaxChars: 2000, ...options });
+    const direct = blockToText(payload, { toolMaxChars: DEFAULT_TOOL_MAX_CHARS, ...options });
     if (direct) return direct;
   }
 
@@ -241,7 +259,7 @@ export function extractTextFromPayload(payload, options = {}) {
   }
 
   if (chunks.length === 0) {
-    const direct = blockToText(payload, { toolMaxChars: 2000, ...options });
+    const direct = blockToText(payload, { toolMaxChars: DEFAULT_TOOL_MAX_CHARS, ...options });
     if (direct) chunks.push(direct);
   }
 
@@ -281,7 +299,7 @@ function collectToolNamesByIdFromPayload(payload, out) {
 }
 
 function extractPartsFromContent(content, options = {}) {
-  const opts = { toolMaxChars: 2000, toolNameById: {}, ...options };
+  const opts = { toolMaxChars: DEFAULT_TOOL_MAX_CHARS, toolNameById: {}, ...options };
   const parts = [];
   if (!content) return parts;
   if (typeof content === "string") {
@@ -309,7 +327,7 @@ function extractPartsFromContent(content, options = {}) {
 
 export function extractPartsFromPayload(payload, options = {}) {
   if (!payload || typeof payload !== "object") return [];
-  const opts = { toolMaxChars: 2000, toolNameById: {}, ...options };
+  const opts = { toolMaxChars: DEFAULT_TOOL_MAX_CHARS, toolNameById: {}, ...options };
   if (payload.message && typeof payload.message === "object") {
     return extractPartsFromPayload(payload.message, opts);
   }
@@ -338,6 +356,53 @@ export function extractPartsFromPayload(payload, options = {}) {
   return parts;
 }
 
+/**
+ * Prune blank text parts and run `cfg.captureFilters` over the ones that remain.
+ *
+ * One drop verdict is taken per turn, on the aggregate of its text parts; the
+ * individual parts are then rewritten with the substitutions only, so a rule can
+ * never both keep and drop the same turn. Tool call/result parts are carried
+ * through untouched — filters match conversation text, not tool payloads — but a
+ * turn dropped on its text takes its tool parts with it.
+ */
+export function filterCaptureParts(parts, role, cfg = {}) {
+  const kept = [];
+  for (const part of parts || []) {
+    if (!part) continue;
+    if (part.type !== "text") {
+      kept.push(part);
+      continue;
+    }
+    const text = typeof part.text === "string" ? part.text.trim() : "";
+    if (!text) continue;
+    kept.push(text === part.text ? part : { ...part, text });
+  }
+
+  const blank = { parts: kept, dropped: false };
+  const compiled = compileInputFilters(cfg?.captureFilters);
+  if (!compiled.rules.length || kept.length === 0) return blank;
+
+  const textParts = kept.filter((part) => part.type === "text");
+  if (textParts.length === 0) return blank;
+
+  const verdict = applyInputFilters(textParts.map((part) => part.text).join("\n\n"), compiled.rules, {
+    role,
+  });
+  if (verdict.dropped) return { parts: [], dropped: true };
+
+  const out = [];
+  for (const part of kept) {
+    if (part.type !== "text") {
+      out.push(part);
+      continue;
+    }
+    const shaped = applyInputFilters(part.text, compiled.rules, { role, substituteOnly: true });
+    if (!shaped.text) continue;
+    out.push(shaped.text === part.text ? part : { ...part, text: shaped.text });
+  }
+  return { parts: out, dropped: out.length === 0 };
+}
+
 export function extractCaptureTurns(rolloutEntries, cfg = {}) {
   const toolNameById = collectToolNamesByIdFromEntries(rolloutEntries);
   const turns = [];
@@ -355,10 +420,15 @@ export function extractCaptureTurns(rolloutEntries, cfg = {}) {
       toolMaxChars: cfg.captureToolMaxChars,
       toolNameById,
     });
-    const decision = shouldCaptureText(rawText, role, cfg);
-    if (!decision.shouldCapture && parts.length === 0) continue;
+    const shaped = filterCaptureParts(parts, role, cfg);
+    if (shaped.dropped) continue;
+    // With parts on the wire the drop decision was already taken above, so the
+    // text path only runs the filters for the `content` fallback. That also
+    // keeps `turn.text` faithful for callers that scan it for trigger words.
+    const decision = shouldCaptureText(rawText, role, cfg, { filters: shaped.parts.length === 0 });
+    if (!decision.shouldCapture && shaped.parts.length === 0) continue;
     const text = decision.shouldCapture ? decision.text : "";
-    turns.push({ role, text, parts });
+    turns.push({ role, text, parts: shaped.parts });
   }
   return turns;
 }
@@ -470,12 +540,21 @@ function isPunctuationOnly(text) {
   return !/[a-z0-9\u3400-\u9fff]/i.test(text);
 }
 
-export function shouldCaptureText(text, role, cfg = {}) {
+export function shouldCaptureText(text, role, cfg = {}, { filters = true } = {}) {
   const maxLength = cfg.captureMaxLength || 24000;
   const sanitized = sanitizeCapturedText(text);
   if (!sanitized) return { shouldCapture: false, reason: "empty", text: "" };
 
-  const capped = truncateCaptureText(sanitized, maxLength);
+  let capped = truncateCaptureText(sanitized, maxLength);
+  if (filters) {
+    const compiled = compileInputFilters(cfg?.captureFilters);
+    if (compiled.rules.length) {
+      const verdict = applyInputFilters(capped, compiled.rules, { role });
+      if (verdict.dropped) return { shouldCapture: false, reason: "filtered", text: "" };
+      capped = verdict.text;
+      if (!capped) return { shouldCapture: false, reason: "empty", text: "" };
+    }
+  }
   const compact = oneLine(capped);
   const isToolSummary = /^\[tool-(?:call|result)\b/i.test(compact);
 

package/lib/shared/credentials.mjs

@@ -192,9 +192,20 @@ export function resolveOpenVikingCredentials(env = process.env) {
   const explicitMcpUrl = str(env.OPENVIKING_MCP_URL, "");
   const mcpUrl = (mode !== "cli" && explicitMcpUrl) ? explicitMcpUrl : `${baseUrl.replace(/\/+$/, "")}/mcp`;
 
+  // The file that actually supplied the api_key, following the same chain —
+  // empty when the key came from the environment or was never found.
+  let credentialPath = "";
+  if (apiKey) {
+    if (useCli) credentialPath = files.cliPath;
+    else if (str(env.OPENVIKING_BEARER_TOKEN, str(env.OPENVIKING_API_KEY, ""))) credentialPath = "";
+    else if (str(files.cliFile.api_key, "")) credentialPath = files.cliPath;
+    else credentialPath = files.ovPath;
+  }
+
   return {
     ...files,
     credentialSource: useCli ? "ovcli" : ((mode === "env" || envHasCredentials) ? "env" : "auto"),
+    credentialPath,
     baseUrl,
     mcpUrl,
     apiKey,

package/lib/shared/input-filters.mjs

@@ -0,0 +1,219 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Ordered, operator-configured regex filters for memory plugin input.
+ *
+ * Rules are sed-style strings, applied in order to a single piece of text:
+ *   s/^\s*ultrathink\s+//i   substitute (add `g` to replace every match)
+ *   d|^\s*[/!]|              drop the text when the pattern matches
+ *   k/^\?ov\b/               keep the text only when the pattern matches
+ *   user:d/^\s*\/clear\b/    apply to one role only
+ *
+ * A malformed rule becomes an entry in `errors` and is skipped rather than
+ * throwing, so a typo in a config file cannot take a hook down.
+ */
+
+const OPS = new Set(["s", "d", "k"]);
+const SCOPES = ["user", "assistant"];
+const ALLOWED_FLAGS = "imsug";
+
+export const INPUT_FILTER_KNOBS = [
+  {
+    key: "recallQueryFilters",
+    env: "OPENVIKING_RECALL_QUERY_FILTERS",
+    label: "recall query filters",
+  },
+  {
+    key: "captureFilters",
+    env: "OPENVIKING_CAPTURE_FILTERS",
+    label: "capture filters",
+  },
+];
+
+/**
+ * Read one delimited field. `\` always consumes the next character, and only
+ * `\<delim>` is un-escaped, so `\d` / `\b` / `\x2c` reach RegExp verbatim.
+ * Returns the index of the closing delimiter, or -1 when it is missing.
+ */
+function scanField(source, start, delim) {
+  let out = "";
+  let i = start;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\\") {
+      const next = source[i + 1];
+      if (next === undefined) {
+        out += "\\";
+        i += 1;
+        continue;
+      }
+      out += next === delim ? next : "\\" + next;
+      i += 2;
+      continue;
+    }
+    if (c === delim) return { value: out, end: i };
+    out += c;
+    i += 1;
+  }
+  return { value: out, end: -1 };
+}
+
+export function parseInputFilterRule(source) {
+  if (typeof source !== "string") {
+    return { source: String(source ?? ""), error: "rule must be a string" };
+  }
+  const raw = source.trim();
+  if (!raw) return { source: raw, error: "rule is empty" };
+
+  let scope = "";
+  let rest = raw;
+  for (const candidate of SCOPES) {
+    if (rest.startsWith(`${candidate}:`)) {
+      scope = candidate;
+      rest = rest.slice(candidate.length + 1);
+      break;
+    }
+  }
+
+  const op = rest[0] || "";
+  if (!OPS.has(op)) {
+    return {
+      source: raw,
+      error: `unknown operation "${op}" — expected s (substitute), d (drop) or k (keep)`,
+    };
+  }
+  const delim = rest[1];
+  if (delim === undefined) {
+    return { source: raw, error: `missing delimiter after "${op}"` };
+  }
+  if (/[A-Za-z0-9\s\\]/.test(delim)) {
+    return {
+      source: raw,
+      error: `invalid delimiter ${JSON.stringify(delim)} — use punctuation such as / | # or :`,
+    };
+  }
+
+  const first = scanField(rest, 2, delim);
+  const pattern = first.value;
+  let replacement = null;
+  let flagsRaw = "";
+  if (op === "s") {
+    if (first.end < 0) {
+      return { source: raw, error: `missing ${JSON.stringify(delim)} after the pattern` };
+    }
+    const second = scanField(rest, first.end + 1, delim);
+    if (second.end < 0) {
+      return {
+        source: raw,
+        error: `missing ${JSON.stringify(delim)} after the replacement — write s${delim}pattern${delim}replacement${delim}`,
+      };
+    }
+    replacement = second.value;
+    flagsRaw = rest.slice(second.end + 1);
+  } else {
+    flagsRaw = first.end < 0 ? "" : rest.slice(first.end + 1);
+  }
+
+  if (!pattern) return { source: raw, error: "pattern is empty" };
+
+  const flags = new Set();
+  for (const flag of flagsRaw) {
+    if (!ALLOWED_FLAGS.includes(flag)) {
+      return { source: raw, error: `unknown flag "${flag}" — allowed flags are i, m, s, u, g` };
+    }
+    if (flags.has(flag)) return { source: raw, error: `duplicate flag "${flag}"` };
+    flags.add(flag);
+  }
+  // d/k decide with .test(), which advances lastIndex on a global regex and
+  // would then alternate between calls. `g` means nothing there, so drop it.
+  if (op !== "s") flags.delete("g");
+
+  let re;
+  try {
+    re = new RegExp(pattern, [...flags].join(""));
+  } catch (err) {
+    // V8 already says "Invalid regular expression: <pattern>: <why>"; keep that
+    // detail without stuttering the prefix the doctors key off.
+    const message = err?.message || String(err);
+    return {
+      source: raw,
+      error: /^invalid regular expression/i.test(message)
+        ? `invalid${message.slice("Invalid".length)}`
+        : `invalid regular expression: ${message}`,
+    };
+  }
+
+  return { op, scope, re, replacement, source: raw };
+}
+
+export function compileInputFilters(rules) {
+  const compiled = [];
+  const errors = [];
+  const list = Array.isArray(rules) ? rules : [];
+  list.forEach((entry, index) => {
+    if (typeof entry !== "string") {
+      errors.push({ index, source: String(entry ?? ""), message: "rule must be a string" });
+      return;
+    }
+    if (!entry.trim()) return;
+    const parsed = parseInputFilterRule(entry);
+    if (parsed.error) errors.push({ index, source: parsed.source, message: parsed.error });
+    else compiled.push({ ...parsed, index });
+  });
+  return { rules: compiled, errors };
+}
+
+/**
+ * Run compiled rules over `text`.
+ *
+ * `substituteOnly` skips the d/k operations, so a caller that already took one
+ * drop decision for a turn can rewrite its individual pieces without taking a
+ * second, possibly contradictory one.
+ */
+export function applyInputFilters(text, compiled, { role = "", substituteOnly = false } = {}) {
+  const original = typeof text === "string" ? text : String(text ?? "");
+  let current = original;
+  for (const rule of Array.isArray(compiled) ? compiled : []) {
+    if (rule.scope && rule.scope !== role) continue;
+    if (rule.op === "s") {
+      current = current.replace(rule.re, rule.replacement);
+      continue;
+    }
+    if (substituteOnly) continue;
+    const matched = rule.re.test(current);
+    if ((rule.op === "d" && matched) || (rule.op === "k" && !matched)) {
+      return { text: "", changed: false, dropped: true, ruleIndex: rule.index, op: rule.op };
+    }
+  }
+  const finalText = current.trim();
+  return {
+    text: finalText,
+    changed: finalText !== original,
+    dropped: false,
+    ruleIndex: -1,
+    op: "",
+  };
+}
+
+/** Doctor-facing summary of both filter knobs on a resolved plugin config. */
+export function describeInputFilters(cfg = {}) {
+  return INPUT_FILTER_KNOBS.map(({ key, env, label }) => {
+    const configured = Array.isArray(cfg?.[key]) ? cfg[key] : [];
+    const compiled = compileInputFilters(configured);
+    const ops = { s: 0, d: 0, k: 0 };
+    for (const rule of compiled.rules) ops[rule.op] += 1;
+    const bits = [];
+    if (ops.s) bits.push(`${ops.s} substitute`);
+    if (ops.d) bits.push(`${ops.d} drop`);
+    if (ops.k) bits.push(`${ops.k} keep-only`);
+    const active = compiled.rules.length;
+    return {
+      key,
+      env,
+      label,
+      total: configured.length,
+      active,
+      summary: `${active} rule${active === 1 ? "" : "s"}${bits.length ? ` (${bits.join(", ")})` : ""}`,
+      errors: compiled.errors,
+    };
+  });
+}

package/lib/shared/mcp-proxy-config.mjs

@@ -0,0 +1,124 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+/**
+ * Shared config shaping for the stdio MCP proxy entrypoints.
+ *
+ * Every harness loads its credentials differently, but the shape
+ * `createOpenVikingMcpProxy` consumes is identical everywhere, and so is the
+ * set of files whose changes must trigger a credential reload. Keeping that
+ * here stops each entrypoint from re-deriving `~` expansion, URL trimming,
+ * timeout clamping, and the watch list.
+ */
+
+import { homedir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+
+export const DEFAULT_PROXY_TIMEOUT_MS = 15000;
+const MIN_PROXY_TIMEOUT_MS = 1000;
+
+export function trimSlash(value) {
+  return String(value || "").replace(/\/+$/, "");
+}
+
+/** Expand a leading `~` and resolve to an absolute path; "" stays "". */
+export function normalizeConfigPath(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);
+}
+
+/**
+ * The credential files every harness must watch: the two `OPENVIKING_*_FILE`
+ * overrides and the two default locations under `~/.openviking`.
+ */
+export function defaultCredentialPaths(env = process.env) {
+  return [
+    normalizeConfigPath(env.OPENVIKING_CLI_CONFIG_FILE),
+    normalizeConfigPath(env.OPENVIKING_CONFIG_FILE),
+    join(homedir(), ".openviking", "ovcli.conf"),
+    join(homedir(), ".openviking", "ov.conf"),
+  ].filter(Boolean);
+}
+
+/**
+ * Resolve the actor peer header for a long-lived MCP proxy process.
+ *
+ * MCP servers may start in the plugin directory rather than the active
+ * workspace, so their process cwd is not a reliable peer identity — and unlike
+ * a hook, a long-lived proxy cannot re-derive one per turn. Broad recall
+ * intentionally spans the authenticated user's peer workspaces and therefore
+ * leaves the actor header unset. Actor-scoped recall needs an explicit peer so
+ * isolation never depends on the proxy's launch directory.
+ *
+ * A missing one degrades to broad recall with a warning rather than refusing to
+ * start: the proxy is what carries every memory tool, and taking those away
+ * because a scope preference cannot be honoured costs the user far more than
+ * the wider search does. Only the harness whose parent process injects the peer
+ * (dsh, `mcp.mjs:27`) can satisfy this without the user setting it.
+ */
+export function resolveMcpActorPeerId({
+  peerId = "",
+  recallPeerScope = "all",
+  onWarn = null,
+} = {}) {
+  if (recallPeerScope !== "actor") return "";
+
+  const explicitPeerId = String(peerId || "").trim();
+  if (explicitPeerId) return explicitPeerId;
+
+  const message = "OpenViking MCP: actor-scoped recall needs an explicit peer id, which an MCP proxy cannot "
+    + "derive from its launch directory. Falling back to broad recall across every peer under this user. "
+    + "Set actor_peer_id in ovcli.conf, or OPENVIKING_PEER_ID in the MCP server environment, to scope it.";
+  if (typeof onWarn === "function") onWarn(message);
+  else process.stderr.write(`${message}\n`);
+  return "";
+}
+
+function uniq(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+/**
+ * Shape a harness's loaded config into the object `createOpenVikingMcpProxy`
+ * expects.
+ *
+ * `mcpUrl` wins over `baseUrl` when both are given, so a harness that lets the
+ * user pin an explicit MCP URL keeps that behavior. `watchedPaths` are the
+ * harness's own extra files; the shared defaults are appended and the result
+ * deduplicated.
+ */
+export function buildMcpProxyConfig({
+  baseUrl = "",
+  mcpUrl = "",
+  apiKey = "",
+  account = "",
+  user = "",
+  peerId = "",
+  userAgent = "",
+  timeoutMs,
+  debug = false,
+  debugLogPath = "",
+  credentialSource = "auto",
+  credentialPath = "",
+  watchedPaths = [],
+  env = process.env,
+} = {}) {
+  return {
+    mcpUrl: mcpUrl || `${trimSlash(baseUrl)}/mcp`,
+    apiKey: apiKey || "",
+    account: account || "",
+    user: user || "",
+    peerId: peerId || "",
+    userAgent: userAgent || "",
+    timeoutMs: Math.max(
+      MIN_PROXY_TIMEOUT_MS,
+      Number(timeoutMs) || DEFAULT_PROXY_TIMEOUT_MS,
+    ),
+    debug: debug === true,
+    debugLogPath,
+    credentialSource: credentialSource || "auto",
+    credentialPath: credentialPath || "",
+    watchedPaths: uniq([...watchedPaths, ...defaultCredentialPaths(env)]),
+  };
+}

package/lib/shared/mcp-proxy-core.mjs

@@ -292,10 +292,22 @@ export function createOpenVikingMcpProxy({
       );
     }
     const msg = err instanceof Error ? err.message : String(err);
+    if (err && err.name === "AbortError") {
+      // Client-side timeout, not an outage: the server may be healthy and
+      // still computing (rerank-inclusive find/search can legitimately take
+      // longer than the default budget). Keep -32001 for genuine
+      // connection failures so the two are not misdiagnosed as each other.
+      return errorResponse(
+        id,
+        -32004,
+        `OpenViking MCP request timed out after ${proxyConfig.timeoutMs}ms (${proxyConfig.mcpUrl}). The server may still be processing (rerank can be slow) — check /health or raise OPENVIKING_TIMEOUT_MS.`,
+        { timeoutMs: proxyConfig.timeoutMs, mcpUrl: proxyConfig.mcpUrl, cause: msg },
+      );
+    }
     return errorResponse(
       id,
       -32001,
-      `OpenViking MCP request failed. Check the configured URL (${proxyConfig.mcpUrl}) and that 'ov serve' is running.`,
+      `OpenViking MCP request failed. Check the configured URL (${proxyConfig.mcpUrl}) and that the OpenViking server (\`openviking-server\`) is reachable.`,
       { cause: msg },
     );
   }

package/lib/shared/pending-queue.mjs

@@ -409,6 +409,17 @@ export async function replayPending(fetchJSON, log) {
       res = { ok: false };
     }
 
+    if (entry.type === "commitSession") {
+      log("pending-queue", {
+        action: "commit-replay",
+        sessionId: entry.sessionId,
+        ok: Boolean(res?.ok),
+        status: res?.result?.status || res?.status,
+        trace_id: res?.traceId || res?.result?.trace_id,
+        error: res?.ok ? undefined : res?.error?.message || res?.error?.code,
+      });
+    }
+
     if (res?.ok) {
       await dequeue(claimedFilename);
       replayed++;