open-memex 0.6.2 → 0.7.0-alpha.1

package/dist/opencode-v2.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
+import { makeTools } from "./tools/memory.js";
+/** Register the five memory tools on a v2 host. */
+async function registerTools(ctx, state) {
+    const tools = makeTools(() => state.scope, state.cfg);
+    await ctx.tool.transform((editor) => {
+        for (const [name, t] of Object.entries(tools)) {
+            editor.add({
+                name,
+                description: t.description,
+                input: z.toJSONSchema(z.object(t.args)),
+                options: { codemode: false },
+                execute: async (input) => {
+                    const r = await t.execute(input, undefined);
+                    const content = typeof r === "string" ? r : (r.output ?? JSON.stringify(r));
+                    return { content };
+                },
+            });
+        }
+    });
+}
+export const v2Plugin = {
+    id: PLUGIN_ID,
+    async setup(ctx) {
+        const root = ctx.location?.directory ?? ctx.location?.project?.directory ?? process.cwd();
+        const state = bootstrapPlugin(root);
+        const registrations = [];
+        await registerTools(ctx, state);
+        registrations.push(await ctx.session.hook("prompt", (ev) => {
+            captureFromText(ev.prompt?.text ?? "", state);
+        }));
+        registrations.push(await ctx.session.hook("context", (ev) => {
+            injectOnce(ev.sessionID ?? "", state, (block) => {
+                ev.system.push({ type: "text", text: block });
+            });
+        }));
+        return () => {
+            for (const r of registrations)
+                void r.dispose?.();
+        };
+    },
+};

package/dist/plugin-core.js

@@ -0,0 +1,138 @@
+import { loadConfig } from "./config.js";
+import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "./scope.js";
+import { db } from "./store/db.js";
+import { syncScope, upsertFromFile } from "./store/sync.js";
+import { scopeHasFiles } from "./store/migrate.js";
+import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, } from "./store/markdown.js";
+import { buildContextBlock } from "./retrieve/inject.js";
+import { detectKeywords } from "./capture/keywords.js";
+import { findDuplicates } from "./store/lifecycle.js";
+import { redact } from "./redact.js";
+/**
+ * Host-agnostic plugin core (D60). Both opencode host generations adapt to
+ * this module: the v1 plugin (src/index.ts `server`) and the v2 plugin
+ * (src/opencode-v2.ts `setup`). Host-specific glue — tool registration and
+ * hook shapes — stays in the adapters; everything memory-shaped lives here.
+ */
+export const PLUGIN_ID = "open-memex";
+/**
+ * Resolve the project scope for a host working directory and bring the
+ * index up to date. Never throws: a broken store must not keep the host
+ * from starting — failures land in the host's log instead.
+ */
+export function bootstrapPlugin(root) {
+    const cfg = loadConfig();
+    const scope = resolveProjectScope(root);
+    try {
+        db();
+        syncScope(scope.key);
+        syncScope(PERSONAL_SCOPE.key);
+        if (cfg.logLevel === "debug") {
+            console.log(`[open-memex] loaded. scope=${scope.key}`);
+        }
+        // If a git remote was added *after* memories were first captured, the
+        // scope key changes (cwd-hash -> origin-hash). Detect the legacy dir on
+        // disk and tell the user how to migrate. We do NOT auto-migrate: two
+        // different repos at the same cwd would collide.
+        const cwdScope = resolveCwdScope(root);
+        if (cwdScope.key !== scope.key && scopeHasFiles(cwdScope.key)) {
+            console.warn(`[open-memex] found memories under legacy scope key "${cwdScope.key}". ` +
+                `Current project scope is "${scope.key}". ` +
+                `To move them: npm run cli -- migrate --from ${cwdScope.key}`);
+        }
+    }
+    catch (err) {
+        console.error("[open-memex] init failed:", err);
+    }
+    return { cfg, scope, injectedSessions: new Set() };
+}
+/**
+ * Keyword capture (§ capture): scan one user message for "remember …"
+ * triggers and save each hit. Shared by the v1 `chat.message` hook and
+ * the v2 session `prompt` hook — both hand us the message text.
+ */
+export function captureFromText(text, state) {
+    const { cfg, scope } = state;
+    if (!cfg.keywordCaptureEnabled || !text)
+        return;
+    const hits = detectKeywords(text, cfg);
+    for (const h of hits) {
+        const { content, hadSecret, matchedPattern } = redact(h.content, cfg.redactPatterns);
+        // Secrets are masked (first 4 chars kept) and the capture proceeds;
+        // skip only when nothing usable remains.
+        if (content.length === 0)
+            continue;
+        if (hadSecret && cfg.logLevel === "debug") {
+            console.log(`[open-memex] keyword capture masked secret (${matchedPattern})`);
+        }
+        // Personal patterns ("remember for me" / "记住（个人）") force the personal scope.
+        const target = h.personal ? PERSONAL_SCOPE : scope;
+        // Dedup (§3.4): skip exact duplicates captured before.
+        if (findDuplicates(target.key, content).exact)
+            continue;
+        const now = Date.now();
+        const rfc = msToRfc3339(now);
+        const fm = {
+            id: ulid(),
+            schema_version: 2,
+            scope_key: target.key,
+            scope: target.kind === "project" ? "project" : "personal",
+            visibility: target.kind === "project" ? "internal" : "private",
+            project_name: target.projectName,
+            type: "fact",
+            role: "knowledge",
+            importance: "normal",
+            status: "active",
+            tags: ["keyword"],
+            source: "keyword",
+            created_at: rfc,
+            updated_at: rfc,
+            supersedes: null,
+            superseded_by: null,
+            review_state: "draft",
+            proposed_by: null,
+            approved_by: null,
+            derived_from: null,
+            review_note: null,
+            review_history: [],
+        };
+        try {
+            const { filePath } = writeMemoryFile(fm, content);
+            const mf = readMemoryFile(filePath);
+            if (mf)
+                upsertFromFile(mf);
+            // Capture feedback: always visible (not debug-only) — the user said
+            // "记住…", they should see that it landed. The opencode plugin API
+            // offers no toast channel, so the plugin log is the feedback surface.
+            const preview = content.length > 60 ? content.slice(0, 60) + "…" : content;
+            console.log(`[open-memex] remembered → ${target.kind} scope: "${preview}"`);
+        }
+        catch (err) {
+            console.error("[open-memex] keyword capture failed:", err);
+        }
+    }
+}
+/**
+ * First-turn context injection: exactly once per session. The host adapter
+ * supplies `push` (v1: output.system.push; v2: the session context hook's
+ * system array). Returns true when a block was pushed.
+ */
+export function injectOnce(sessionID, state, push) {
+    const { cfg, scope } = state;
+    if (!cfg.injectOnFirstTurn)
+        return false;
+    if (state.injectedSessions.has(sessionID))
+        return false;
+    state.injectedSessions.add(sessionID);
+    try {
+        const block = buildContextBlock(scope, cfg);
+        if (block) {
+            push(block);
+            return true;
+        }
+    }
+    catch (err) {
+        console.error("[open-memex] context injection failed:", err);
+    }
+    return false;
+}

package/docs/V2-DESIGN.md

@@ -1210,6 +1210,46 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   `@opencode-ai/plugin`, the exact D58 death. It checks only what can be
   attributed; per-project and MCP wiring are out of scope.
 
+- **D60** — one plugin serves both opencode generations (0.7.0-alpha.1).
+  Opencode 2 changes the plugin contract end to end: config reads
+  `plugins` (directories or `{package}` objects) instead of v1's
+  `plugin` file entries, a v1-style file entry only earns a log warning
+  ("configured plugin path must be a directory") and is silently skipped
+  — the D58 death in a new shape; and the plugin value itself is a
+  structurally decoded `{ id, setup(ctx) }` rather than the v1 server
+  factory. A single `open-memex init --client opencode --global` now
+  writes both keys (`plugin` file URL and `plugins` directory): each
+  host loads from its own key — verified: opencode 1.18.34 ignores the
+  `plugins` array with a config-normalization warning, and opencode 2
+  warns per `plugin` file entry but loads the directory entry — so users on either generation get a
+  working plugin from the same install. `src/index.ts` default-exports
+  `{ id, setup, server }`: v2 calls `setup`, v1 calls `server`, the
+  shared logic (bootstrap, keyword capture, one-time injection) lives in
+  `src/plugin-core.ts`. Cost of the bridge on the v1 side: v1 hosts
+  older than 1.18.29 only invoke function default exports and would
+  skip this object; 1.18.29+ accepts it — the README states the new
+  minimum. The v2 adapter (src/opencode-v2.ts) obeys D58's rule — no
+  runtime `@opencode/plugin` import (a devDependency again); the
+  context is duck-typed from the 2.0 surface, tool arg shapes compile
+  from the same zod shapes via `z.toJSONSchema`, and hooks map
+  one-to-one (session `prompt` → keyword capture, session `context` →
+  first-turn injection). One registration subtlety cost real debugging
+  time and is worth recording: on 2.0.1 a plugin tool added without
+  options is exposed to the model only in code mode — callable through
+  an `execute` meta-tool that runs model-written JS
+  (`tools.memory_search(...)`) — and a model that instead calls the
+  tool by name gets a host-side "Unknown tool" error, so whether the
+  memory tools work at all depends on the model's calling style. Each
+  tool therefore registers with `options: { codemode: false }`, which
+  restores plain function calling (verified: direct calls execute
+  first try). The D59 doctor check extends to both keys:
+  v2 entries are checked for an existing, resolvable entry file and the
+  closure scan now covers `@opencode/plugin` too, plus a generation
+  advisory — when the installed host and the config point at different
+  generations, doctor fails and names the fix (`init --force`; package-
+  name entries installed via `opencode plugin add` are recorded but not
+  path-checked). Field-verified on real hosts 1.18.34 and 2.0.1.
+
 ## Open Questions
 
 _All resolved — see D10 (rename), D11 (type/role split), D12 (explicit pull)._

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.6.2",
+  "version": "0.7.0-alpha.1",
   "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/smoke-pure.ts

@@ -9,7 +9,7 @@ import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/sco
 import { cjkIndexText, cjkQueryExpr, hasCjk } from "../src/retrieve/cjk.ts";
 import { toFtsQuery } from "../src/retrieve/query.ts";
 import { contentHash, similarity, NEAR_DUP_THRESHOLD } from "../src/store/lifecycle.ts";
-import { userMcpConfigPath, mergeServerEntry, detectInstalledClients, mergePluginEntry, opencodeGlobalConfigPath, printManualEntryHint, parseJsonConfig, removeServerEntry, removePluginEntry, removeInstructionsSection, LEGACY_PACKAGE_NAME, shouldInstallSkill } from "../src/init.ts";
+import { userMcpConfigPath, mergeServerEntry, detectInstalledClients, mergePluginEntry, mergeV2PluginEntry, removeV2PluginEntry, opencodeGlobalConfigPath, printManualEntryHint, parseJsonConfig, removeServerEntry, removePluginEntry, removeInstructionsSection, LEGACY_PACKAGE_NAME, shouldInstallSkill } from "../src/init.ts";
 
 let fails = 0;
 function ok(name: string, cond: boolean, info?: unknown) {
@@ -504,6 +504,27 @@ ok("plugin remove absent", removePluginEntry({ plugin: ["other"] }, "open-memex"
 const lpdoc: Record<string, unknown> = { plugin: ["file:///g/my-o-memory/src/index.ts", "file:///g/open-memex/src/index.ts"] };
 ok("plugin remove drops legacy my-o-memory entry", removePluginEntry(lpdoc, LEGACY_PACKAGE_NAME) === "removed"
   && JSON.stringify(lpdoc["plugin"]) === JSON.stringify(["file:///g/open-memex/src/index.ts"]));
+// D60: the OpenCode 2 `plugins` array (directory strings and {package} objects).
+const vdoc: Record<string, unknown> = {};
+ok("v2 merge creates array", mergeV2PluginEntry(vdoc, "/x/open-memex/src", false) === "added"
+  && JSON.stringify(vdoc["plugins"]) === JSON.stringify(["/x/open-memex/src"]));
+ok("v2 merge dup kept", mergeV2PluginEntry(vdoc, "/x/open-memex/src", false) === "kept");
+const vdoc2: Record<string, unknown> = { plugins: [{ package: "other-plugin", options: {} }, "/old/open-memex/src"] };
+ok("v2 merge kept with existing open-memex entry (no force)", mergeV2PluginEntry(vdoc2, "/new/open-memex/src", false) === "kept"
+  && (vdoc2["plugins"] as unknown[]).length === 2);
+ok("v2 merge force replaces stale open-memex dir, keeps others", mergeV2PluginEntry(vdoc2, "/new/open-memex/src", true) === "added"
+  && (vdoc2["plugins"] as unknown[]).length === 2
+  && JSON.stringify(vdoc2["plugins"]) === JSON.stringify([{ package: "other-plugin", options: {} }, "/new/open-memex/src"]));
+ok("v2 remove drops string + object entries", removeV2PluginEntry(vdoc2, "open-memex") === "removed"
+  && JSON.stringify(vdoc2["plugins"]) === JSON.stringify([{ package: "other-plugin", options: {} }]));
+ok("v2 remove absent", removeV2PluginEntry(vdoc2, "open-memex") === "absent");
+const vdoc3: Record<string, unknown> = { plugins: ["/x/open-memex/src"] };
+ok("v2 remove prunes empty array", removeV2PluginEntry(vdoc3, "open-memex") === "removed" && !("plugins" in vdoc3));
+// D60: the plugin entrypoint default-exports both host generations.
+const entryModule = (await import("../src/index.ts")) as { default: { id?: unknown; setup?: unknown; server?: unknown } };
+ok("entry default export has id/setup/server", entryModule.default.id === "open-memex"
+  && typeof entryModule.default.setup === "function"
+  && typeof entryModule.default.server === "function");
 // removeInstructionsSection: cuts MARKER..end, "" when nothing remains.
 ok("instructions remove keeps prior content",
   removeInstructionsSection("# mine\n\n<!-- open-memex -->\n# OpenMemex memory\n") === "# mine\n");

package/src/doctor.ts

@@ -94,14 +94,17 @@ function lockingCheck(): Check {
 }
 
 /**
- * D59: patrol the opencode native-plugin entry. The D58 field failure was
- * silent — the entry was configured, the host never loaded it, and nothing
- * anywhere said why. Two death modes to catch:
- *   1. the entry's target file does not exist (package moved, nvm rolled
- *      to a new version dir, checkout deleted);
- *   2. the plugin's import closure runtime-imports @opencode-ai/plugin
- *      (or another host-only module the package does not depend on),
- *      which is unresolvable from a global install (D58 regression).
+ * D59/D60: patrol the opencode native-plugin entries. The D58 field failure
+ * was silent — the entry was configured, the host never loaded it, and
+ * nothing anywhere said why. Death modes to catch:
+ *   1. the entry's target does not exist (package moved, nvm rolled to a
+ *      new version dir, checkout deleted);
+ *   2. the plugin's import closure runtime-imports a host SDK package
+ *      (@opencode-ai/plugin on v1, @opencode/plugin on v2) — unresolvable
+ *      from a global install, the host silently skips the plugin (D58);
+ *   3. (D60) the config wires only the other host generation: an
+ *      opencode 2 host never reads the v1 `plugin` file entry (it demands
+ *      a directory under `plugins`), and opencode 1 cannot read `plugins`.
  * Read-only; only inspects the user-level opencode configs.
  */
 function opencodePluginCheck(): Check {
@@ -109,23 +112,37 @@ function opencodePluginCheck(): Check {
   try {
     const jsonPath = opencodeGlobalConfigPath();
     const candidates = [jsonPath, jsonPath.replace(/\.json$/, ".jsonc")];
-    const entries: string[] = [];
+    const v1Entries: string[] = [];
+    const v2Entries: string[] = [];
     let sawConfig = false;
+    const v2EntryPackage = (entry: unknown): string | null => {
+      if (typeof entry === "string") return entry;
+      if (entry !== null && typeof entry === "object" && "package" in entry) {
+        const p = (entry as { package?: unknown }).package;
+        return typeof p === "string" ? p : null;
+      }
+      return null;
+    };
     for (const f of candidates) {
       if (!fs.existsSync(f)) continue;
       sawConfig = true;
       const text = fs.readFileSync(f, "utf8");
       try {
-        const doc = JSON.parse(text) as { plugin?: unknown };
-        const list = Array.isArray(doc.plugin) ? doc.plugin : [];
-        for (const e of list) {
-          if (typeof e === "string") entries.push(e);
+        const doc = JSON.parse(text) as { plugin?: unknown; plugins?: unknown };
+        if (Array.isArray(doc.plugin)) {
+          for (const e of doc.plugin) if (typeof e === "string") v1Entries.push(e);
+        }
+        if (Array.isArray(doc.plugins)) {
+          for (const e of doc.plugins) {
+            const p = v2EntryPackage(e);
+            if (p !== null) v2Entries.push(p);
+          }
         }
       } catch {
         // JSONC (comments/trailing commas): fall back to scanning quoted
         // strings for plugin entries.
         for (const m of text.matchAll(/"(file:[^"]+|[^"]+\.(?:ts|js|mts|mjs))"/g)) {
-          entries.push(m[1]!);
+          v1Entries.push(m[1]!);
         }
       }
     }
@@ -134,23 +151,63 @@ function opencodePluginCheck(): Check {
     }
 
     const problems: string[] = [];
+    // Host SDK packages per generation; a runtime import of either from a
+    // globally installed plugin cannot resolve (D58).
     const RUNTIME_SDK_IMPORT =
-      /^\s*import\s+(?!type\b)[^;]*?["']@opencode-ai\/plugin(?:\/[^"']*)?["']/m;
-    const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode-ai\/plugin(?:\/[^"']*)?["']\s*\)/;
+      /^\s*import\s+(?!type\b)[^;]*?["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']/m;
+    const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']\s*\)/;
 
+    const toPath = (entry: string): string | null => {
+      try {
+        return entry.startsWith("file:") ? fileURLToPath(entry) : entry;
+      } catch {
+        return null;
+      }
+    };
     // An entry is ours when its path names the package, or when the target
     // file carries the plugin's "[open-memex]" log marker (source checkouts
     // can live at any path).
-    const isOurEntry = (entry: string): boolean => {
-      if (entry.includes("open-memex")) return true;
+    const fileHasMarker = (target: string): boolean => {
       try {
-        const target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-        if (!fs.existsSync(target)) return false;
         return fs.readFileSync(target, "utf8").slice(0, 65536).includes("[open-memex]");
       } catch {
         return false;
       }
     };
+    /** Resolve an OpenCode 2 directory entry to its entry file, if any. */
+    const resolveV2EntryFile = (target: string): string | null => {
+      try {
+        if (!fs.existsSync(target)) return null;
+        if (fs.statSync(target).isFile()) return target;
+        for (const idx of ["index.ts", "index.js", "index.mts", "index.mjs"]) {
+          const p = path.join(target, idx);
+          if (fs.existsSync(p)) return p;
+        }
+        const pkgJson = path.join(target, "package.json");
+        if (fs.existsSync(pkgJson)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8")) as { main?: unknown };
+          if (typeof pkg.main === "string") {
+            const main = path.join(target, pkg.main);
+            if (fs.existsSync(main)) return main;
+          }
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    };
+    const isOursV1 = (entry: string): boolean => {
+      if (entry.includes("open-memex")) return true;
+      const target = toPath(entry);
+      return target !== null && fs.existsSync(target) && fileHasMarker(target);
+    };
+    const isOursV2 = (entry: string): boolean => {
+      if (entry.includes("open-memex")) return true;
+      const target = toPath(entry);
+      if (target === null) return false;
+      const file = resolveV2EntryFile(target);
+      return file !== null && fileHasMarker(file);
+    };
     const scanSdkImports = (entryFile: string): string[] => {
       // Walk the entry's relative-import closure looking for host-SDK
       // runtime imports (type-only imports are erased and fine).
@@ -184,15 +241,14 @@ function opencodePluginCheck(): Check {
       return offenders;
     };
 
-    const ours = entries.filter(isOurEntry);
-    if (ours.length === 0) {
+    const oursV1 = v1Entries.filter(isOursV1);
+    const oursV2 = v2Entries.filter(isOursV2);
+    if (oursV1.length === 0 && oursV2.length === 0) {
       return { name, ok: true, detail: "no global plugin entry (per-project or MCP wiring is not checked)" };
     }
-    for (const entry of ours) {
-      let target: string;
-      try {
-        target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-      } catch {
+    for (const entry of oursV1) {
+      const target = toPath(entry);
+      if (target === null) {
         problems.push(`entry "${entry}" is not a parseable file URL`);
         continue;
       }
@@ -204,17 +260,72 @@ function opencodePluginCheck(): Check {
       }
       for (const f of scanSdkImports(target)) {
         problems.push(
-          `${f} runtime-imports @opencode-ai/plugin — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`,
+          `${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`,
+        );
+      }
+    }
+    for (const entry of oursV2) {
+      // A bare package name ("open-memex" via `opencode plugin add`) is
+      // resolved by the host's plugin manager; there is no local path to
+      // verify.
+      const isPackageName =
+        !entry.startsWith("file:") &&
+        !entry.startsWith(".") &&
+        !path.isAbsolute(entry) &&
+        !/^[a-zA-Z]:[\\/]/.test(entry);
+      if (isPackageName) continue;
+      const target = toPath(entry);
+      if (target === null || !fs.existsSync(target)) {
+        problems.push(
+          `opencode 2 entry "${entry}" does not resolve to an existing path — run \`open-memex init --client opencode --global --force\` to re-point it`,
+        );
+        continue;
+      }
+      const entryFile = resolveV2EntryFile(target);
+      if (entryFile === null) {
+        problems.push(
+          `opencode 2 entry "${entry}" has no loadable plugin file (looked for index.ts/index.js and package.json main)`,
         );
+        continue;
       }
+      for (const f of scanSdkImports(entryFile)) {
+        problems.push(
+          `${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`,
+        );
+      }
+    }
+
+    // D60: generation mismatch — the config wires only the generation the
+    // installed host cannot read. Best-effort: no binary, no opinion.
+    let hostMajor: number | null = null;
+    try {
+      const out = execFileSync("opencode", ["--version"], {
+        timeout: 3000,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      const m = out.match(/(\d+)\.(\d+)\.(\d+)/);
+      if (m) hostMajor = Number(m[1]);
+    } catch {
+      hostMajor = null;
     }
+    if (hostMajor !== null && hostMajor >= 2 && oursV1.length > 0 && oursV2.length === 0) {
+      problems.push(
+        `the installed opencode is v${hostMajor} but the config only has the opencode 1 "plugin" entry — v2 loads directories from "plugins" and will silently skip this plugin; run \`open-memex init --client opencode --global --force\` to add the v2 entry`,
+      );
+    } else if (hostMajor === 1 && oursV2.length > 0 && oursV1.length === 0) {
+      problems.push(
+        `the installed opencode is v1 but the config only has the opencode 2 "plugins" entry — v1 reads the "plugin" key and will not load this plugin; run \`open-memex init --client opencode --global --force\` to add the v1 entry`,
+      );
+    }
+
     if (problems.length > 0) {
       return { name, ok: false, detail: problems.join("; ") };
     }
     return {
       name,
       ok: true,
-      detail: `${ours.length} plugin ${ours.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
+      detail: `${oursV1.length + oursV2.length} plugin ${oursV1.length + oursV2.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
     };
   } catch (err) {
     return { name, ok: false, detail: String(err) };