@openviking/opencode-plugin 2026.9.24 → 2026.9.25-2

package/INSTALL-ZH.md

@@ -11,7 +11,7 @@
 
 需要先准备：
 
-- OpenCode
+- OpenCode 1.15.7+ 或 OpenCode 2.0.15+
 - OpenViking HTTP Server
 - Node.js 18+
 - 如果服务端启用了认证，需要可用的 OpenViking API Key
@@ -38,6 +38,8 @@ curl http://localhost:1933/health
 }
 ```
 
+这份 `plugin` 配置同时兼容 v1 和 v2；v2 会在加载时规范化为原生的 `plugins`，无需手工迁移配置。
+
 ## 安装方式二：源码安装
 
 用于开发调试或 PR 测试。OpenCode 推荐插件目录：

package/INSTALL.md

@@ -11,7 +11,7 @@ This is the only OpenCode plugin example maintained in this repository. It does
 
 Prepare the following first:
 
-- OpenCode
+- OpenCode 1.15.7+ or OpenCode 2.0.15+
 - OpenViking HTTP Server
 - Node.js 18+
 - A valid OpenViking API key if authentication is enabled on the server
@@ -38,6 +38,8 @@ Normal users are recommended to enable it through OpenCode's package plugin mech
 }
 ```
 
+This `plugin` entry works on both v1 and v2. OpenCode v2 normalizes it to the native `plugins` form at load time, so no manual config migration is required.
+
 ## Installation Method 2: Source Install
 
 Use this method for development, debugging, or PR testing. OpenCode's recommended plugin directory is:

package/README.md

@@ -17,6 +17,7 @@ The plugin uses OpenCode hooks for lifecycle behavior and registers OpenViking's
 - 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.
+- On OpenCode v2, reads the structured session context at execution boundaries so tool calls and results are captured too.
 - 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 `openviking_read`, `openviking_glob`, or `openviking_search`. Shell commands that carry a `viking://` URI still run, with a notice appended to their output.
@@ -50,11 +51,13 @@ There is intentionally no `skills/openviking/SKILL.md`. The tool surface comes f
 
 ## Requirements
 
-- OpenCode
+- OpenCode 1.15.7+ or OpenCode 2.0.15+
 - OpenViking HTTP server
 - Node.js 18+
 - An OpenViking API key if your server requires authentication
 
+The same package serves both plugin APIs. OpenCode 1 calls `server()` (or the named `OpenVikingPlugin` export), while OpenCode 2 calls `setup()`. The v2 entrypoint does not import `@opencode/plugin`, so a source install on OpenCode 1 still loads. OpenCode 2 normalizes the installer's `"plugin"` key to `"plugins"`; keep `"plugin"` in shared v1/v2 configuration. On v2, the bundled MCP server uses `codemode: false`, preserving the documented `openviking_*` tool names.
+
 Start OpenViking first:
 
 ```bash
@@ -202,6 +205,8 @@ call and points it to the OpenViking MCP tools. A `bash` command that contains a
 an HTTP payload); the command runs and the plugin appends a notice naming the
 MCP tools to its output.
 
+OpenCode v2 has no plugin toast API. Service availability and other non-fatal notices are written to `openviking-memory.log`. The plugin captures the transcript before compaction discards it, checks the commit threshold after every execution (succeeded, failed, or interrupted), and forces a commit after completed compaction, session deletion, and cleanup. Each plugin instance handles only the sessions of its own location, and keeps its capture cursor in OpenCode plugin storage so a reloaded instance does not resend earlier turns.
+
 ## MCP Tools
 
 OpenCode sees the OpenViking MCP server as `openviking`, so tool names are namespaced with `openviking_`.

package/index.mjs

@@ -1,41 +1,30 @@
 import { dirname } from "path"
 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 { createMemoryRecall } from "./lib/memory-recall.mjs"
-import { createSessionInject } from "./lib/session-inject.mjs"
-import { createVikingUriGuard, createVikingUriNotice } from "./lib/viking-uri-guard.mjs"
+import { createOpenVikingRuntime } from "./lib/plugin-runtime.mjs"
+import { startV2Plugin } from "./lib/v2-plugin.mjs"
 import { injectOpenVikingMcpConfig } from "./lib/mcp-config.mjs"
-import { loadConfig, resolveDataDir } from "./lib/config.mjs"
 import { isRecallEnabled } from "./lib/shared/recall-core.mjs"
-import { initLogger, log, makeToast } from "./lib/utils.mjs"
+import { log } from "./lib/utils.mjs"
 
 const pluginRoot = dirname(fileURLToPath(import.meta.url))
 
-export async function OpenVikingPlugin({ client, directory }) {
-  const config = loadConfig(pluginRoot, directory)
-  const dataDir = resolveDataDir(pluginRoot, config)
-  initLogger(dataDir)
-
-  if (!config.enabled) {
-    log("INFO", "plugin", "OpenViking plugin is disabled in configuration")
-    return {}
-  }
-
-  const repoContext = createRepoContext({ config })
-  const sessionManager = createMemorySessionManager({ config, pluginRoot: dataDir })
-  const recall = createMemoryRecall({ config, sessionManager })
-  const sessionInject = createSessionInject({ config, sessionManager })
-  const vikingUriGuard = createVikingUriGuard()
-  const vikingUriNotice = createVikingUriNotice()
+export async function OpenVikingPlugin({ client, directory } = {}) {
+  const runtime = createOpenVikingRuntime({ client, directory, pluginRoot })
+  if (!runtime) return {}
+  await runtime.ready
+  return v1Hooks(runtime)
+}
 
-  await sessionManager.init()
-  const toast = makeToast(client)
-  Promise.resolve().then(async () => {
-    const ready = await initializeRuntime(config, client)
-    if (ready) await repoContext.refreshRepos({ force: true })
-  })
+function v1Hooks(runtime) {
+  const {
+    config,
+    sessionManager,
+    repoContext,
+    recall,
+    sessionInject,
+    vikingUriGuard,
+    vikingUriNotice,
+  } = runtime
 
   return {
     config: async (opencodeConfig) => {
@@ -67,9 +56,18 @@ export async function OpenVikingPlugin({ client, directory }) {
 
     "chat.message": async (input, output) => {
       try {
-        await sessionInject.injectSessionContext(input, output)
-        if (!isRecallEnabled(config)) return
-        await recall.injectRelevantMemories(input, output)
+        // opencode awaits this hook before persisting/broadcasting the user
+        // message, so serial awaits here stack remote latency onto message
+        // display (#5148). Session inject and recall are independent after
+        // entry; overlap them the way the dsh plugin does (#4643).
+        if (!isRecallEnabled(config)) {
+          await sessionInject.injectSessionContext(input, output)
+          return
+        }
+        await Promise.all([
+          sessionInject.injectSessionContext(input, output),
+          recall.injectRelevantMemories(input, output),
+        ])
       } catch (error) {
         log("WARN", "recall", "Auto recall failed", { error: error?.message ?? String(error) })
       }
@@ -92,4 +90,17 @@ export async function OpenVikingPlugin({ client, directory }) {
   }
 }
 
-export default OpenVikingPlugin
+const OpenVikingV2Plugin = {
+  id: "openviking",
+  async setup(ctx) {
+    const directory = ctx?.location?.project?.directory || ctx?.location?.directory
+    const runtime = createOpenVikingRuntime({ directory, pluginRoot })
+    if (!runtime) return
+    return startV2Plugin(ctx, runtime, { pluginRoot })
+  },
+  async server(input) {
+    return OpenVikingPlugin(input)
+  },
+}
+
+export default OpenVikingV2Plugin

package/lib/mcp-config.mjs

@@ -11,6 +11,19 @@ export function createOpenVikingMcpConfig(pluginRoot) {
   }
 }
 
+export function createOpenVikingV2McpConfig(pluginRoot) {
+  return {
+    type: "local",
+    command: ["node", resolvePath(pluginRoot, "servers", "mcp-proxy.mjs")],
+    codemode: false,
+    timeout: {
+      startup: 15000,
+      catalog: 15000,
+      execution: 15000,
+    },
+  }
+}
+
 export function injectOpenVikingMcpConfig(config, pluginRoot, enabled = true) {
   if (!config || typeof config !== "object") return false
   if (!enabled) return false

package/lib/memory-recall.mjs

@@ -3,12 +3,12 @@ import { isBypassed } from "./shared/session-model.mjs"
 import { effectivePeerId, fetchJSON, log } from "./utils.mjs"
 
 export function createMemoryRecall({ config, sessionManager }) {
-  async function injectRelevantMemories(input, output) {
+  async function buildRelevantMemories(input, parts) {
     if (!isRecallEnabled(config)) return
-    const query = extractCurrentUserText(output.parts ?? [])
+    const query = extractCurrentUserText(parts ?? [])
     if (!query) return
     if (query.length < config.minQueryLength) return
-    const sessionID = input.sessionID ?? output.message?.sessionID
+    const sessionID = input.sessionID
     if (isBypassed(config, {
       sessionId: sessionID,
       cwd: input.directory ?? input.cwd,
@@ -34,14 +34,20 @@ export function createMemoryRecall({ config, sessionManager }) {
         log: (stage, data) => log("DEBUG", "recall", stage, data),
       },
     )
-    if (!block) return
+    return block || undefined
+  }
 
-    if (prependSyntheticRecallPart(input, output, block)) {
+  async function injectRelevantMemories(input, output) {
+    const block = await buildRelevantMemories({
+      ...input,
+      sessionID: input.sessionID ?? output.message?.sessionID,
+    }, output.parts)
+    if (block && prependSyntheticRecallPart(input, output, block)) {
       log("INFO", "recall", "Injected OpenViking context")
     }
   }
 
-  return { injectRelevantMemories }
+  return { buildRelevantMemories, injectRelevantMemories }
 }
 
 export function extractCurrentUserText(parts) {

package/lib/memory-session.mjs

@@ -1,10 +1,9 @@
 import fs from "fs"
 import path from "path"
 import {
-  extractPartsFromPayload,
   extractTextFromPayload,
   isCaptureEnabled,
-  shouldCaptureText,
+  shapeCapturePayload,
 } from "./shared/capture-utils.mjs"
 import {
   deriveHarnessSessionId,
@@ -31,6 +30,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
   const statePath = path.join(pluginRoot, "openviking-session-state.json")
   const oldSessionMapPath = path.join(pluginRoot, "openviking-session-map.json")
   let saveTimer = null
+  let initBackground = Promise.resolve()
   // Serialize saves: concurrent saveState() calls (a debounced save racing
   // with flushAll / flushSession / session deletion) all share the same
   // `${statePath}.tmp` temp file, so one rename can fail with ENOENT after
@@ -46,16 +46,24 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     return run
   }
 
-  async function init() {
-    if (isCaptureEnabled(config)) await migrateLegacySessionMap()
+  async function init({ deferNetwork = false } = {}) {
     await loadState()
-    const health = await fetchJSON(config, "/health", {}, { timeoutMs: 5000 })
-    if (health.ok) {
+    initBackground = Promise.resolve().then(async () => {
+      if (isCaptureEnabled(config)) await migrateLegacySessionMap()
+      const health = await fetchJSON(config, "/health", {}, { timeoutMs: 5000 })
+      if (!health.ok) return
       await replayPending(
         (endpoint, init = {}, options = {}) => fetchJSON(config, endpoint, init, options),
         (stage, data) => log("DEBUG", "pending", stage, data),
       )
-    }
+    }).catch((error) => {
+      log("WARN", "pending", "Pending replay failed during initialization", { error: error?.message })
+    })
+    if (!deferNetwork) await initBackground
+  }
+
+  async function waitForBackground() {
+    await initBackground
   }
 
   async function loadState() {
@@ -117,7 +125,9 @@ export function createMemorySessionManager({ config, pluginRoot }) {
         {
           role: message.role,
           captured: message.captured,
-          parts: Array.from(message.parts.entries()),
+          // Captured messages are never read by flushPendingMessages again; retain
+          // only their metadata so completed payloads cannot grow the state file.
+          parts: message.captured ? [] : Array.from(message.parts.entries()),
         },
       ])),
     }
@@ -306,6 +316,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
 
   return {
     init,
+    waitForBackground,
     handleEvent,
     getMappedSessionId,
     commitSession,
@@ -371,18 +382,17 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     if (!role) return null
     if (role === "assistant" && !config.captureAssistantTurns) return null
 
-    const rawText = partsRaw
-      .map((part) => extractTextFromPayload(part, { toolMaxChars: config.captureToolMaxChars }))
-      .filter(Boolean)
-      .join("\n\n")
-    const captureParts = partsRaw.flatMap((part) => extractPartsFromPayload(part, {
-      toolMaxChars: config.captureToolMaxChars,
-    }))
-    const decision = shouldCaptureText(rawText, role, config)
-    if (!decision.shouldCapture && captureParts.length === 0) return null
-    const body = captureParts.length > 0
-      ? { role, parts: captureParts }
-      : { role, content: decision.text }
+    const shaped = shapeCapturePayload({ role, content: partsRaw }, role, config)
+    const toolParts = shaped.parts.filter((part) => part.type !== "text")
+    if (shaped.dropped || (!shaped.text && toolParts.length === 0)) return null
+    const body = toolParts.length > 0
+      ? { role, parts: [
+        ...(shaped.text && shaped.parts.some((part) => part.type === "text")
+          ? [{ type: "text", text: shaped.text }]
+          : []),
+        ...toolParts,
+      ] }
+      : { role, content: shaped.text }
     const peerId = effectivePeerId(config)
     if (peerId) body.peer_id = peerId
     return body

package/lib/plugin-runtime.mjs

@@ -0,0 +1,51 @@
+import { createRepoContext } from "./repo-context.mjs"
+import { createMemorySessionManager } from "./memory-session.mjs"
+import { createMemoryRecall } from "./memory-recall.mjs"
+import { createSessionInject } from "./session-inject.mjs"
+import { createVikingUriGuard, createVikingUriNotice } from "./viking-uri-guard.mjs"
+import { loadConfig, resolveDataDir } from "./config.mjs"
+import { initializeRuntime } from "./runtime.mjs"
+import { initLogger, log } from "./utils.mjs"
+
+export function createOpenVikingRuntime({ client, directory, pluginRoot }) {
+  const config = loadConfig(pluginRoot, directory)
+  const dataDir = resolveDataDir(pluginRoot, config)
+  initLogger(dataDir)
+
+  if (!config.enabled) {
+    log("INFO", "plugin", "OpenViking plugin is disabled in configuration")
+    return null
+  }
+
+  const repoContext = createRepoContext({ config })
+  const sessionManager = createMemorySessionManager({ config, pluginRoot: dataDir })
+  const recall = createMemoryRecall({ config, sessionManager })
+  const sessionInject = createSessionInject({ config, sessionManager })
+  const vikingUriGuard = createVikingUriGuard()
+  const vikingUriNotice = createVikingUriNotice()
+
+  // OpenCode v2 has no v1 client object and waits for setup before accepting
+  // the first prompt. Load local state before hooks run, but keep health and
+  // pending replay off that activation path.
+  const ready = sessionManager.init({ deferNetwork: !client })
+  const background = ready.then(async () => {
+    const healthy = await initializeRuntime(config, client)
+    if (healthy) await repoContext.refreshRepos({ force: true })
+  }).catch((error) => {
+    log("WARN", "plugin", "OpenViking runtime initialization failed", {
+      error: error?.message ?? String(error),
+    })
+  })
+
+  return {
+    config,
+    repoContext,
+    sessionManager,
+    recall,
+    sessionInject,
+    vikingUriGuard,
+    vikingUriNotice,
+    ready,
+    background,
+  }
+}

package/lib/session-inject.mjs

@@ -4,10 +4,10 @@ import { effectivePeerId, fetchJSON, log } from "./utils.mjs"
 export function createSessionInject({ config, sessionManager }) {
   const injectedSessions = new Set()
 
-  async function injectSessionContext(input, output) {
+  async function buildSessionContext(input) {
     if (config.noAutoInject) return false
-    const sessionID = input.sessionID ?? output.message?.sessionID
-    const messageID = input.messageID ?? output.message?.id
+    const sessionID = input.sessionID
+    const messageID = input.messageID
     if (!sessionID || !messageID || injectedSessions.has(sessionID)) return false
 
     const ovSessionId = sessionManager.getMappedSessionId(sessionID)
@@ -26,7 +26,7 @@ export function createSessionInject({ config, sessionManager }) {
 
     if (parts.length === 0) {
       injectedSessions.add(sessionID)
-      return false
+      return undefined
     }
 
     const block = [
@@ -35,14 +35,6 @@ export function createSessionInject({ config, sessionManager }) {
       "</openviking-context>",
     ].join("\n")
 
-    output.parts.unshift({
-      id: `prt-ov-session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      type: "text",
-      text: block,
-      synthetic: true,
-      sessionID,
-      messageID,
-    })
     injectedSessions.add(sessionID)
     log("INFO", "session-inject", "Injected OpenViking session context", {
       opencode_session: sessionID,
@@ -50,10 +42,28 @@ export function createSessionInject({ config, sessionManager }) {
       hasProfile: Boolean(profile?.block),
       hasArchive: Boolean(archive),
     })
+    return block
+  }
+
+  async function injectSessionContext(input, output) {
+    const block = await buildSessionContext({
+      ...input,
+      sessionID: input.sessionID ?? output.message?.sessionID,
+      messageID: input.messageID ?? output.message?.id,
+    })
+    if (!block) return false
+    output.parts.unshift({
+      id: `prt-ov-session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      type: "text",
+      text: block,
+      synthetic: true,
+      sessionID: input.sessionID ?? output.message?.sessionID,
+      messageID: input.messageID ?? output.message?.id,
+    })
     return true
   }
 
-  return { injectSessionContext }
+  return { buildSessionContext, injectSessionContext }
 }
 
 async function fetchArchiveBlock(fetcher, ovSessionId, tokenBudget) {

package/lib/shared/capture-utils.mjs

@@ -409,6 +409,61 @@ export function filterCaptureParts(parts, role, cfg = {}) {
   return { parts: out, dropped: out.length === 0 };
 }
 
+/** Sanitize already-extracted message parts before applying capture rules. */
+export function shapeCaptureParts(parts, role, cfg = {}) {
+  const sanitized = (parts || []).map((part) => part?.type === "text"
+    ? { ...part, text: sanitizeCapturedText(part.text) }
+    : part);
+  return filterCaptureParts(sanitized, role, cfg);
+}
+
+function faithfulCaptureDecision(text, cfg) {
+  const sanitized = sanitizeCapturedText(text);
+  if (!sanitized) return { shouldCapture: false, text: "" };
+  const capped = truncateCaptureText(sanitized, cfg.captureMaxLength || 24000);
+  const compact = oneLine(capped);
+  if (/^\[openviking-memory\]/i.test(compact) || SLASH_COMMAND_RE.test(compact)) {
+    return { shouldCapture: false, text: "" };
+  }
+  return { shouldCapture: true, text: capped };
+}
+
+/**
+ * Shape one host message before an adapter builds its session payload.
+ * Sanitize injected context before evaluating keep/drop rules, so text that
+ * will not be sent cannot satisfy a keep rule. Tool parts are never filtered.
+ */
+export function shapeCapturePayload(payload, role, cfg = {}, { toolNameById = {}, faithful = false } = {}) {
+  const options = { toolMaxChars: cfg.captureToolMaxChars, toolNameById };
+  const rawText = extractTextFromPayload(payload, options);
+  const sourceParts = extractPartsFromPayload(payload, options);
+  const hasTextPart = sourceParts.some((part) => part?.type === "text");
+  const sanitizedText = sanitizeCapturedText(rawText);
+  // Some hosts supply an array of plain strings. It has text but no structured
+  // parts, so use a temporary part for the same filter verdict.
+  const fallback = sourceParts.length === 0 && sanitizedText
+    ? [{ type: "text", text: rawText }]
+    : [];
+  const shaped = shapeCaptureParts(sourceParts.length ? sourceParts : fallback, role, cfg);
+  if (shaped.dropped) return { parts: [], text: "", signalText: "", dropped: true };
+
+  const parts = sourceParts.length ? shaped.parts : [];
+  const decisionText = hasTextPart || fallback.length
+    ? shaped.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n\n")
+    : sanitizedText;
+  const decision = faithful
+    ? faithfulCaptureDecision(decisionText, cfg)
+    : shouldCaptureText(decisionText, role, cfg, { filters: false });
+  // Codex scans turn.text for explicit-memory keywords; keep that scan based
+  // on the user's original words while the filtered parts go on the wire.
+  const signalText = decision.shouldCapture && parts.length
+    ? (faithful
+      ? faithfulCaptureDecision(sanitizedText, cfg)
+      : shouldCaptureText(sanitizedText, role, cfg, { filters: false })).text
+    : decision.text;
+  return { parts, text: decision.shouldCapture ? decision.text : "", signalText: signalText || "", dropped: false };
+}
+
 export function extractCaptureTurns(rolloutEntries, cfg = {}) {
   const toolNameById = collectToolNamesByIdFromEntries(rolloutEntries);
   const turns = [];
@@ -421,20 +476,9 @@ export function extractCaptureTurns(rolloutEntries, cfg = {}) {
     if (!role) continue;
     if (isAssistantSideCaptureRole(rawRole) && !cfg.captureAssistantTurns) continue;
 
-    const rawText = extractTextFromPayload(payload, { toolMaxChars: cfg.captureToolMaxChars });
-    const parts = extractPartsFromPayload(payload, {
-      toolMaxChars: cfg.captureToolMaxChars,
-      toolNameById,
-    });
-    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: shaped.parts });
+    const shaped = shapeCapturePayload(payload, role, cfg, { toolNameById });
+    if (shaped.dropped || (!shaped.text && shaped.parts.length === 0)) continue;
+    turns.push({ role, text: shaped.parts.length ? shaped.signalText : shaped.text, parts: shaped.parts });
   }
   return turns;
 }
@@ -555,7 +599,7 @@ export function sanitizeCapturedText(text) {
     .replace(/^[ \t]*\[Subagent Context\][^\n]*$/gim, " ")
     .replace(/^\s*Sender\s*\([^)]+\)\s*```[\s\S]*?```\s*/gim, " ")
     .replace(/^\s*Conversation (?:metadata|info):\s*```[\s\S]*?```\s*/gim, " ")
-    .replace(/^\s*\[?\d{4}-\d{2}-\d{2}[T ][^\]\n]{3,80}\]?\s*/gm, "")
+    .replace(/^[ \t]*\[\d{4}-\d{2}-\d{2}[T ][-+0-9:.Z]{5,35}\][ \t]*/gm, "")
     .replace(/^\s*\d{10,13}\s+/gm, "");
   value = stripMetadataFences(value);
   value = stripInjectedDigestBlocks(value);
@@ -598,16 +642,18 @@ export function shouldCaptureText(text, role, cfg = {}, { filters = true } = {})
   const sanitized = sanitizeCapturedText(text);
   if (!sanitized) return { shouldCapture: false, reason: "empty", text: "" };
 
-  let capped = truncateCaptureText(sanitized, maxLength);
+  // Rules judge the full sanitized turn; the wire cap applies afterward.
+  let filtered = sanitized;
   if (filters) {
     const compiled = compileInputFilters(cfg?.captureFilters);
     if (compiled.rules.length) {
-      const verdict = applyInputFilters(capped, compiled.rules, { role });
+      const verdict = applyInputFilters(filtered, compiled.rules, { role });
       if (verdict.dropped) return { shouldCapture: false, reason: "filtered", text: "" };
-      capped = verdict.text;
-      if (!capped) return { shouldCapture: false, reason: "empty", text: "" };
+      filtered = verdict.text;
+      if (!filtered) return { shouldCapture: false, reason: "empty", text: "" };
     }
   }
+  const capped = truncateCaptureText(filtered, maxLength);
   const compact = oneLine(capped);
   const isToolSummary = /^\[tool-(?:call|result)\b/i.test(compact);
 

package/lib/utils.mjs

@@ -56,10 +56,12 @@ export function log(level, toolName, message, data) {
 }
 
 export function makeToast(client) {
-  return (message, variant = "warning") =>
-    client?.tui?.showToast?.({
+  return (message, variant = "warning") => {
+    const request = client?.tui?.showToast?.({
       body: { title: "OpenViking", message, variant, duration: 8000 },
-    }).catch(() => {})
+    })
+    return request?.catch?.(() => {})
+  }
 }
 
 export function normalizeEndpoint(endpoint) {

package/lib/v2-events.mjs

@@ -0,0 +1,102 @@
+export function normalizeV2LifecycleEvent(event) {
+  const type = event?.type
+  const data = event?.data && typeof event.data === "object" ? event.data : {}
+  const sessionID = data.sessionID ?? data.sessionId
+  if (!type || !sessionID) return []
+
+  if (type === "session.created") {
+    return [sessionEvent("session.created", sessionID, { parentID: data.parentID })]
+  }
+  if (type === "session.deleted") {
+    return [sessionEvent("session.deleted", sessionID)]
+  }
+  if (type === "session.compaction.ended") {
+    return [sessionEvent("session.compacted", sessionID)]
+  }
+  // A failed execution ends one turn, not the session, so it keeps state like
+  // the other terminal outcomes instead of taking v1's session.error path.
+  if (
+    type === "session.execution.succeeded" ||
+    type === "session.execution.interrupted" ||
+    type === "session.execution.failed"
+  ) {
+    return [sessionEvent("session.idle", sessionID)]
+  }
+  return []
+}
+
+export function contextMessageEvents(sessionID, message) {
+  if (!sessionID || !message?.id) return []
+  if (message.type === "user") {
+    if (typeof message.text !== "string" || !message.text.trim()) return []
+    return [
+      messageUpdated(sessionID, message.id, "user"),
+      partUpdated(sessionID, message.id, `${message.id}:text`, { type: "text", text: message.text }),
+    ]
+  }
+  if (message.type !== "assistant") return []
+
+  const events = [messageUpdated(sessionID, message.id, "assistant")]
+  for (const [index, block] of (message.content ?? []).entries()) {
+    const part = contentPart(block, index)
+    if (part) events.push(partUpdated(sessionID, message.id, part.id, part))
+  }
+  return events.length > 1 ? events : []
+}
+
+function sessionEvent(type, sessionID, info = {}) {
+  return {
+    type,
+    properties: { info: { id: sessionID, sessionID, ...info } },
+  }
+}
+
+function contentPart(block, index) {
+  if (!block || typeof block !== "object") return null
+  // Reasoning is dropped, matching v1 parts and the shared capture filter.
+  if (block.type === "text") {
+    return {
+      id: `text:${index}`,
+      type: "text",
+      text: typeof block.text === "string" ? block.text : "",
+    }
+  }
+  if (block.type !== "tool") return null
+  const output = toolContentText(block.state?.content) || errorText(block.state?.error)
+  return {
+    id: block.id || `tool:${index}`,
+    type: "tool",
+    callID: block.id,
+    tool: block.name,
+    state: block.state,
+    output,
+  }
+}
+
+function toolContentText(content) {
+  if (!Array.isArray(content)) return ""
+  return content
+    .filter((item) => item?.type === "text" && typeof item.text === "string")
+    .map((item) => item.text)
+    .join("\n\n")
+}
+
+function errorText(error) {
+  if (typeof error === "string") return error
+  if (typeof error?.message === "string") return error.message
+  return ""
+}
+
+function messageUpdated(sessionID, messageID, role) {
+  return {
+    type: "message.updated",
+    properties: { info: { sessionID, id: messageID, role } },
+  }
+}
+
+function partUpdated(sessionID, messageID, partId, part) {
+  return {
+    type: "message.part.updated",
+    properties: { part: { ...part, id: partId, sessionID, messageID } },
+  }
+}

package/lib/v2-plugin.mjs

@@ -0,0 +1,352 @@
+import { isRecallEnabled } from "./shared/recall-core.mjs"
+import { createOpenVikingV2McpConfig } from "./mcp-config.mjs"
+import { contextMessageEvents, normalizeV2LifecycleEvent } from "./v2-events.mjs"
+import { log } from "./utils.mjs"
+
+const METADATA_KEY = "openviking"
+const CURSOR_KEY_PREFIX = "capture-cursor/"
+const LIFECYCLE_EVENTS = new Set([
+  "session.created",
+  "session.deleted",
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "session.execution.interrupted",
+  "session.compaction.ended",
+])
+
+export async function startV2Plugin(ctx, runtime, { pluginRoot }) {
+  const {
+    config,
+    sessionManager,
+    repoContext,
+    recall,
+    sessionInject,
+    vikingUriGuard,
+    vikingUriNotice,
+  } = runtime
+  const captureCursors = new Map()
+  const sessionOwnership = new Map()
+  // Compaction hooks can run while lifecycle events are still flushing. Keep
+  // capture and flush ordered so the same pending message is never sent twice.
+  let sessionTask = Promise.resolve()
+  const serializeSession = (operation) => {
+    const task = sessionTask.then(operation)
+    sessionTask = task.catch(() => {})
+    return task
+  }
+  const directory = ctx?.location?.project?.directory || ctx?.location?.directory
+
+  if (config.mcp.enabled && ctx?.mcp?.transform) {
+    await ctx.mcp.transform((editor) => {
+      const current = editor.get?.("openviking")
+      if (current?.disabled === true) return
+      editor.set("openviking", createOpenVikingV2McpConfig(pluginRoot))
+    })
+    log("INFO", "mcp", "Registered OpenViking MCP server for OpenCode v2")
+  } else if (!config.mcp.enabled) {
+    log("INFO", "mcp", "Skipped bundled MCP registration in hook-only mode")
+  }
+
+  if (ctx?.tool?.hook) {
+    await ctx.tool.hook("execute.before", async (event) => {
+      await runtime.ready
+      await vikingUriGuard(
+        { tool: event.tool, args: event.input },
+        { args: event.input },
+      )
+    })
+    await ctx.tool.hook("execute.after", async (event) => {
+      try {
+        await runtime.ready
+        await noticeV2Tool(event, vikingUriNotice)
+      } catch (error) {
+        logHookError("tool.execute.after", error)
+      }
+    })
+  }
+
+  if (ctx?.session?.hook) {
+    await ctx.session.hook("prompt", async (event) => {
+      try {
+        await runtime.ready
+        await prepareV2Prompt(event, {
+          directory,
+          recall,
+          sessionInject,
+          recallEnabled: isRecallEnabled(config),
+        })
+      } catch (error) {
+        logHookError("session.prompt", error)
+      }
+    })
+
+    await ctx.session.hook("context", async (event) => {
+      try {
+        await runtime.ready
+        injectV2Context(event, repoContext)
+      } catch (error) {
+        logHookError("session.context", error)
+      }
+    })
+
+    await ctx.session.hook("compaction", async (event) => {
+      try {
+        await runtime.ready
+        // context() drops the old transcript as soon as compaction completes.
+        // Capture it now; the ended event below owns the commit.
+        await serializeSession(() => captureV2Context(ctx, sessionManager, captureCursors, event.sessionID))
+      } catch (error) {
+        logHookError("session.compaction.capture", error)
+      }
+    })
+  }
+
+  const controller = new AbortController()
+  let eventTask = Promise.resolve()
+  if (ctx?.event?.subscribe) {
+    eventTask = consumeEvents(ctx, controller.signal, async (event) => {
+      const sessionID = event?.data?.sessionID ?? event?.data?.sessionId
+      if (!LIFECYCLE_EVENTS.has(event?.type) || !sessionID) return
+      if (!(await ownsSession(ctx, sessionOwnership, event, sessionID))) return
+      await serializeSession(async () => {
+        await runtime.ready
+        if (event.type === "session.execution.failed") {
+          log("WARN", "v2", "OpenCode v2 execution failed", {
+            opencode_session: sessionID,
+            error: event.data?.error?.message ?? event.data?.error,
+          })
+        }
+        if (isExecutionBoundary(event.type)) {
+          try {
+            await captureV2Context(ctx, sessionManager, captureCursors, sessionID)
+          } catch (error) {
+            logHookError("session.context.capture", error)
+          }
+        }
+        for (const normalized of normalizeV2LifecycleEvent(event)) {
+          await sessionManager.handleEvent(normalized)
+          if (normalized.type === "session.created") {
+            await repoContext.refreshRepos({ force: true })
+          }
+        }
+        if (event.type === "session.deleted") {
+          sessionOwnership.delete(sessionID)
+          await forgetCursor(ctx, captureCursors, sessionID)
+        }
+      })
+    })
+  }
+
+  return async () => {
+    controller.abort()
+    try {
+      await eventTask
+      await sessionTask
+      await runtime.ready
+      await runtime.background
+      await sessionManager.waitForBackground?.()
+      await sessionManager.flushAll({ commit: true })
+    } catch (error) {
+      logHookError("plugin.cleanup", error)
+    }
+    log("INFO", "plugin", "OpenViking plugin disposed")
+  }
+}
+
+async function consumeEvents(ctx, signal, handle) {
+  try {
+    for await (const event of ctx.event.subscribe({ signal })) {
+      try {
+        await handle(event)
+      } catch (error) {
+        logHookError(`event.${event?.type || "unknown"}`, error)
+      }
+    }
+  } catch (error) {
+    if (signal.aborted) return
+    logHookError("event.subscribe", error)
+  }
+}
+
+export async function prepareV2Prompt(event, {
+  directory,
+  recall,
+  sessionInject,
+  recallEnabled,
+}) {
+  const sessionID = event?.sessionID
+  const messageID = event?.messageID
+  if (!sessionID || !messageID) return
+  const text = event?.prompt?.text
+  const parts = typeof text === "string" && text.trim() ? [{ type: "text", text }] : []
+  const input = { sessionID, messageID, directory }
+  const blocks = []
+  try {
+    const sessionBlock = await sessionInject.buildSessionContext(input)
+    if (sessionBlock) blocks.push(sessionBlock)
+  } catch (error) {
+    logHookError("session.prompt.profile", error)
+  }
+  if (recallEnabled) {
+    try {
+      const recallBlock = await recall.buildRelevantMemories(input, parts)
+      if (recallBlock) blocks.push(recallBlock)
+    } catch (error) {
+      logHookError("session.prompt.recall", error)
+    }
+  }
+  if (blocks.length === 0) return
+
+  event.metadata = event.metadata && typeof event.metadata === "object" ? event.metadata : {}
+  event.metadata[METADATA_KEY] = { context: blocks }
+}
+
+export function injectV2Context(event, repoContext) {
+  const repoPrompt = repoContext.getRepoSystemPrompt()
+  if (repoPrompt) pushSystem(event, repoPrompt)
+  if (!Array.isArray(event?.messages)) return
+
+  for (const message of event.messages) {
+    const blocks = message?.metadata?.[METADATA_KEY]?.context
+    if (message?.role !== "user" || !Array.isArray(blocks) || blocks.length === 0) continue
+    if (!Array.isArray(message.content)) message.content = []
+    if (message.content.some((part) => part?.metadata?.[METADATA_KEY] === true)) continue
+    message.content.unshift({
+      type: "text",
+      text: blocks.filter((block) => typeof block === "string" && block).join("\n\n"),
+      metadata: { [METADATA_KEY]: true },
+    })
+  }
+}
+
+// The plugin event stream carries every location served by the process, and
+// execution events have no envelope location, so ownership comes from the
+// session itself. An unresolvable session is handled rather than dropped.
+async function ownsSession(ctx, ownership, event, sessionID) {
+  if (event.type === "session.created") {
+    const owned = sameLocation(event.location ?? event.data?.location, ctx.location)
+    ownership.set(sessionID, owned)
+    return owned
+  }
+  if (event.location) return sameLocation(event.location, ctx.location)
+  if (ownership.has(sessionID)) return ownership.get(sessionID)
+  if (event.type === "session.deleted" || !ctx.session?.get) return true
+  try {
+    const result = await ctx.session.get({ sessionID })
+    const location = (result?.data ?? result)?.location
+    if (location?.directory) {
+      const owned = sameLocation(location, ctx.location)
+      ownership.set(sessionID, owned)
+      return owned
+    }
+  } catch (error) {
+    logHookError("session.get", error)
+  }
+  return true
+}
+
+function sameLocation(ref, location) {
+  if (!ref?.directory || !location?.directory) return true
+  if (ref.directory !== location.directory) return false
+  return !ref.workspaceID || !location.workspaceID || ref.workspaceID === location.workspaceID
+}
+
+export async function captureV2Context(ctx, sessionManager, cursors, sessionID) {
+  const messages = await ctx.session.context({ sessionID })
+  if (!Array.isArray(messages)) return
+  // The cursor lives in host storage because the session state file is shared
+  // by every location instance and cannot prove what was already captured.
+  const cursor = cursors.get(sessionID) ?? await readCursor(ctx, sessionID)
+  const cursorIndex = cursor ? messages.findIndex((message) => message?.id === cursor) : -1
+  const pending = cursorIndex >= 0 ? messages.slice(cursorIndex + 1) : messages
+  for (const message of pending) {
+    for (const normalized of contextMessageEvents(sessionID, message)) {
+      await sessionManager.handleEvent(normalized)
+    }
+  }
+  const last = messages.at(-1)?.id
+  if (!last) return
+  cursors.set(sessionID, last)
+  if (last !== cursor) await writeCursor(ctx, sessionID, last)
+}
+
+async function readCursor(ctx, sessionID) {
+  if (!ctx?.storage?.get) return undefined
+  try {
+    const value = await ctx.storage.get(CURSOR_KEY_PREFIX + sessionID)
+    return typeof value === "string" ? value : undefined
+  } catch (error) {
+    logHookError("storage.get", error)
+    return undefined
+  }
+}
+
+async function writeCursor(ctx, sessionID, cursor) {
+  if (!ctx?.storage?.set) return
+  try {
+    await ctx.storage.set(CURSOR_KEY_PREFIX + sessionID, cursor)
+  } catch (error) {
+    logHookError("storage.set", error)
+  }
+}
+
+async function forgetCursor(ctx, cursors, sessionID) {
+  cursors.delete(sessionID)
+  if (!ctx?.storage?.remove) return
+  try {
+    await ctx.storage.remove(CURSOR_KEY_PREFIX + sessionID)
+  } catch (error) {
+    logHookError("storage.remove", error)
+  }
+}
+
+function isExecutionBoundary(type) {
+  return type === "session.execution.succeeded" ||
+    type === "session.execution.failed" ||
+    type === "session.execution.interrupted"
+}
+
+function pushSystem(event, text) {
+  if (!text) return
+  if (!Array.isArray(event.system)) event.system = []
+  if (event.system.some((part) => part?.type === "text" && part.text === text)) return
+  event.system.push({ type: "text", text })
+}
+
+function logHookError(hook, error) {
+  log("WARN", "v2", `OpenCode v2 ${hook} failed`, {
+    error: error?.message ?? String(error),
+  })
+}
+
+async function noticeV2Tool(event, vikingUriNotice) {
+  if (event?.status !== "completed") return
+  const before = toolResultText(event.result)
+  const output = { output: before }
+  await vikingUriNotice({ tool: event.tool, args: event.input }, output)
+  if (!output.output || output.output === before) return
+  writeToolResultText(event.result, output.output)
+}
+
+function toolResultText(result) {
+  if (!result || typeof result !== "object") return ""
+  if (typeof result.content === "string") return result.content
+  if (!Array.isArray(result.content)) return ""
+  return result.content
+    .filter((item) => item?.type === "text" && typeof item.text === "string")
+    .map((item) => item.text)
+    .join("\n\n")
+}
+
+function writeToolResultText(result, text) {
+  if (!result || typeof result !== "object") return
+  if (typeof result.content === "string" || result.content == null) {
+    result.content = text
+    return
+  }
+  if (!Array.isArray(result.content)) return
+  // Preserve the original text/media blocks and append only the new notice.
+  const before = toolResultText(result)
+  const notice = text.startsWith(before) ? text.slice(before.length).trimStart() : text
+  if (notice) result.content.push({ type: "text", text: notice })
+}

package/lib/viking-uri-guard.mjs

@@ -18,6 +18,10 @@ const FILESYSTEM_TOOL_HINTS = {
     tool: "openviking_read or openviking_search",
     example: (uri) => `openviking_read(uris=["${uri}"])`,
   },
+  shell: {
+    tool: "openviking_read or openviking_search",
+    example: (uri) => `openviking_read(uris=["${uri}"])`,
+  },
 }
 
 export function createVikingUriGuard() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "2026.9.24",
+  "version": "2026.9.25-2",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -24,7 +24,7 @@
   ],
   "scripts": {
     "prepack": "node ../memory-plugin-shared/sync.mjs",
-    "check": "node --check index.mjs && node --check lib/config.mjs && node --check lib/mcp-config.mjs && node --check lib/runtime.mjs && node --check lib/repo-context.mjs && node --check lib/memory-session.mjs && node --check lib/memory-recall.mjs && node --check lib/session-inject.mjs && node --check lib/viking-uri-guard.mjs && node --check lib/utils.mjs && node --check lib/shared/*.mjs && node --check servers/mcp-proxy.mjs && node --check scripts/setup.mjs && node --check tests/*.test.mjs",
+    "check": "node --check index.mjs && node --check lib/config.mjs && node --check lib/mcp-config.mjs && node --check lib/runtime.mjs && node --check lib/plugin-runtime.mjs && node --check lib/v2-events.mjs && node --check lib/v2-plugin.mjs && node --check lib/repo-context.mjs && node --check lib/memory-session.mjs && node --check lib/memory-recall.mjs && node --check lib/session-inject.mjs && node --check lib/viking-uri-guard.mjs && node --check lib/utils.mjs && node --check lib/shared/*.mjs && node --check servers/mcp-proxy.mjs && node --check scripts/setup.mjs && node --check tests/*.test.mjs",
     "test": "node --test tests/*.test.mjs"
   },
   "dependencies": {},
@@ -45,5 +45,5 @@
     "code-search"
   ],
   "license": "Apache-2.0",
-  "openvikingSourceCommit": "20a97022d52277f2000b9014b8c10817192ad020"
+  "openvikingSourceCommit": "3e02c6ac29842be214fa1560dfaf6ea39a69322c"
 }