open-memex 0.7.0-alpha.11 → 0.7.0-alpha.13

package/AGENTS.md

@@ -126,6 +126,7 @@ Layout: `memories/<scope_key>/<id>.md` (YAML frontmatter + body) + `index.db` (S
 
 - `personal` scope key is literal `"personal"` (v1 called this `user`; renamed in v2, design §19).
 - `project` scope key: `project__<sanitized-name>__<12-hex-sha256>`, seeded from normalized git origin URL, else lowercased cwd. See `src/scope.ts`. Same repo across machines → same key (intentional; enables future git-commit of memories).
+- The root a host adapter seeds on matters: OpenCode v1 reports the **filesystem root** as `worktree` for non-git folders, so the v1 adapter goes through `pickScopeRoot` (src/scope.ts) — `worktree` only when it is a real directory below the filesystem root, else the opened `directory` (D71). Seeding on a filesystem root merges every non-git folder on a drive into one `project__workspace__…` bucket.
 - `org`, `team`, `public` are reserved — the schema rejects writes. See `docs/SCOPES.md`.
 - The scope key **changes** when a repo gains/loses a git origin. `src/index.ts` logs a one-shot warning on load if it finds files under the legacy cwd-only key (`resolveCwdScope`). Use `cli scopes` to enumerate all scope dirs and `cli migrate --from <old>` to reconcile — see `src/store/migrate.ts`. No auto-migration; two unrelated repos at the same cwd would silently merge.
 - Read-only callers must use `memoriesDirPath` (in `src/paths.ts`), never `memoriesDirFor`. The latter `mkdir -p`s the directory as a side effect and will pollute storage with empty scope dirs.
@@ -167,9 +168,9 @@ Context injection happens exactly once per session in `experimental.chat.system.
 
 ## Design constraints — read the frozen design first
 
-`docs/V2-DESIGN.md` is the frozen protocol v0.2 (decisions settled through D69; open questions tracked at the end of the doc). Per its §12:
+`docs/V2-DESIGN.md` is the frozen protocol v0.2 (decisions settled through D71; open questions tracked at the end of the doc). Per its §12:
 AGENTS.md answers "how should AI work here"; the design doc answers "why is it
-built this way" (principles, iron rules, the append-only decision log, currently D1–D70). Before changing
+built this way" (principles, iron rules, the append-only decision log, currently D1–D71). Before changing
 architecture, scope semantics, lifecycle, or the protocol surface (frontmatter
 schema, MCP tools, CLI contract), read the relevant design section — the decision
 log records what was already considered and rejected.

package/CHANGELOG.md

@@ -9,6 +9,10 @@ the `@alpha` tag are development snapshots and are not listed individually.
 
 ## [Unreleased]
 
+## Non-git folders shared one scope bucket (D71)
+
+- **Fixed: every non-git folder on a drive shared a single project scope.** OpenCode v1 reports the filesystem root (`C:\`, `/`) as the project `worktree` when the opened folder is not a git repo, and the plugin seeded its scope on that root — so unrelated folders like `C:\temp` and `C:\scratch` all wrote to one `project__workspace__…` bucket. The scope now seeds on the folder actually opened (`pickScopeRoot` in `src/scope.ts`); real repo worktrees are unchanged. Memories already saved under the shared bucket are not moved automatically: run `open-memex scopes` to spot it, then `open-memex migrate --from <old-key>`.
+
 ## Visibility follow-ups: one number, one guard, one truth (D70)
 
 Review of the D68/D69 inventory surfaces — each was honest on its own, and they disagreed with each other:
@@ -29,7 +33,7 @@ Review of the D68/D69 inventory surfaces — each was honest on its own, and the
 Group 3-C — the surface a user reads to learn what the store actually remembers:
 
 - **`memory_list` is now a numbered inventory.** Lines are structured (`[type] id=… created=… source=…`), keep the raw provenance, and every listing states its true total — a truncated list says how many entries it is not showing instead of quietly looking complete. New input `include: "active" | "all"` (default `active`): **behavior change** — superseded versions, retracted and archived memories no longer appear unless you pass `include=all` (the audit view). The CLI gains the matching `list --include` flag.
-- **`open-memex inventory`** renders the same data as readable text (default) or JSON (`--format json`, format `open-memex-inventory/2` — bumped from `/1` in D70, which dropped the absolute file path) — personal plus the current project, outbox drafts in their own section, hidden history counted rather than silently dropped. A report containing personal memories refuses to be written inside a git working tree without `--allow-personal`.
+- **`open-memex inventory`** renders the same data as readable text (default) or JSON (`--format json`, format `open-memex-inventory/1`) — personal plus the current project, outbox drafts in their own section, hidden history counted rather than silently dropped. A report containing personal memories refuses to be written inside a git working tree without `--allow-personal`.
 - **Hide instead of delete:** `memory_forget` gains `soft=true` (CLI: `forget --soft`) — the memory is retracted: out of lists and search, file kept. Still one-way (D64): bringing the fact back means saving it again.
 - **Guidance kept in one voice:** the tool descriptions, the MCP session-start instructions, SKILL.md and the `distill-agents` AGENTS.md snippet all teach the same flow — answer "what do you remember?" conversationally from the inventory, re-list before acting on a number, read an entry back before deleting it.
 

package/dist/.build-stamp

@@ -1 +1 @@
-2800e45cb31d71e3355d41c293cc51de833adec76995ac95b42d10707d04bb92
+f8a813363fbd1433ce149e78defa533d42be7ccbb7f37f1d53be64cd48b90c14

package/dist/index.js

@@ -1,4 +1,5 @@
 import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
+import { pickScopeRoot } from "./scope.js";
 import { makeTools } from "./tools/memory.js";
 import { v2Plugin } from "./opencode-v2.js";
 /**
@@ -12,8 +13,9 @@ import { v2Plugin } from "./opencode-v2.js";
  * type-only (D58), and v2's decode is structural.
  */
 const server = async ({ worktree, directory }) => {
-    const roots = worktree || directory || process.cwd();
-    const state = bootstrapPlugin(roots);
+    // v1's `worktree` is the filesystem root for non-git folders — never seed a
+    // scope on it (D71). `pickScopeRoot` falls back to the opened `directory`.
+    const state = bootstrapPlugin(pickScopeRoot(worktree, directory));
     const tools = makeTools(() => state.scope, state.cfg);
     return {
         tool: tools,

package/dist/scope.js

@@ -57,6 +57,23 @@ export function resolveCwdScope(worktree) {
         projectName = "workspace";
     return scopeFromSeed(seed, projectName);
 }
+/** Pick the directory that seeds scope resolution from a host's candidate
+ *  roots. OpenCode v1 hands the plugin both `worktree` (the repo root — but
+ *  the filesystem root, e.g. `C:\` or `/`, when the opened folder is not a
+ *  git repo) and `directory` (the folder actually opened). Seeding on a
+ *  filesystem root collapses every non-git folder on a drive into one shared
+ *  `project__workspace__…` scope (D71), so prefer `worktree` only when it is
+ *  a real directory below the filesystem root. */
+export function pickScopeRoot(worktree, directory) {
+    const isFsRoot = (p) => path.parse(p).root === p;
+    if (worktree && !isFsRoot(worktree))
+        return worktree;
+    if (directory)
+        return directory;
+    if (worktree)
+        return worktree;
+    return process.cwd();
+}
 export function resolveProjectScope(worktree) {
     const target = worktree && worktree.length > 0 ? worktree : ".";
     const remote = tryGitRemote(target);

package/docs/V2-DESIGN.md

@@ -1,6 +1,6 @@
 # OpenMemex — Design Document (protocol v0.2)
 
-**Status:** FROZEN — protocol v0.2 (2026-09-26). Decisions D1–D70 are settled; open questions are tracked at the end of this document.
+**Status:** FROZEN — protocol v0.2 (2026-09-26). Decisions D1–D71 are settled; open questions are tracked at the end of this document.
 **Author:** Stone, with 小沐
 **Changelog vs v1:** incorporates round-3 review from Perplexity, Grok, Gemini, ChatGPT, DeepSeek.
 Key changes: Design Principles section; `role` separated from `type`; two iron rules;
@@ -1469,18 +1469,22 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   entry back before deleting. The HTML rendering of the same data layer
   follows as a separate change; auto-draft stays gated on the unlock
   conditions in the design doc.
-
-- **D69 — inventory HTML rendering lands (3-C complete on the visibility side).**
-  `open-memex inventory --format html` renders the D68 data layer into a
-  single local page: scopes grouped, outbox drafts in their own section,
-  replaced/hidden history folded with supersede-chain pointers, all
-  content escaped, filter box is local show/hide (no innerHTML, no
-  network). Default output is the data dir's `inventory.html`; the D68
-  worktree refusal applies unchanged. Sections fold above 50 current
-  entries. With this, the 3-C visibility surfaces are complete (agent
-  inventory in chat, text/JSON reports, HTML page; hide + confirmed
-  delete as the correction actions). Auto-draft remains gated on the
-  unlock conditions in `docs/memory-visibility-design.md`.
+- **D71 — the scope seed is the folder opened, never a filesystem root.**
+  OpenCode v1 hands the plugin two roots: `worktree` (the repo root — but
+  the filesystem root itself, `C:\` or `/`, when the opened folder is not a
+  git repo) and `directory` (the folder actually opened). The v1 adapter
+  preferred `worktree`, so every non-git folder on a drive seeded its scope
+  on the drive root and collapsed into one shared
+  `project__workspace__<hash of the root>` bucket — a `c:\temp` project
+  landing in `project__workspace__3dc8472eaebe` (seed `c:\`) is what
+  surfaced it. `pickScopeRoot` (src/scope.ts) now takes `worktree` only when
+  it is a real directory below the filesystem root, else `directory`. The
+  repo-root behavior is unchanged: a real worktree still wins, so opening a
+  repo subfolder keeps the repo's scope. Memories already written under a
+  root-seeded key stay where they are (no auto-migration, per the existing
+  rule); `open-memex scopes` shows the stray bucket and
+  `open-memex migrate --from <old-key>` moves them. The v2 adapter already
+  seeded on the opened directory and is unaffected.
 
 - **D70 — visibility follow-ups: one number, one guard, one truth.** The
   3-C review of D68/D69 found the surfaces honest individually and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.7.0-alpha.11",
+  "version": "0.7.0-alpha.13",
   "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

@@ -5,7 +5,7 @@ import { planConversion, isV2File, migrateV2 } from "../src/store/v2migrate.ts";
 import { redact, findSecret } from "../src/redact.ts";
 import { detectKeywords, scanKeywords } from "../src/capture/keywords.ts";
 import { DEFAULT_CONFIG } from "../src/config.ts";
-import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/scope.ts";
+import { resolveProjectScope, resolveCwdScope, pickScopeRoot, PERSONAL_SCOPE } from "../src/scope.ts";
 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";
@@ -379,6 +379,17 @@ ok("cwd scope deterministic", cwdOnly.key === cwdOnly2.key);
 // (This repo does have an origin after `git push`.)
 console.log("     cwd.key   =", cwdOnly.key);
 
+console.log("== scope (pickScopeRoot, D71) ==");
+// OpenCode v1 reports the filesystem root as `worktree` for non-git folders;
+// seeding a scope on it merges every non-git folder on the drive into one
+// shared `project__workspace__…` bucket. A real worktree still wins.
+const fsRoot = path.parse(process.cwd()).root;
+ok("real worktree wins", pickScopeRoot(process.cwd(), "/elsewhere/opened") === process.cwd());
+ok("fs-root worktree yields to directory", pickScopeRoot(fsRoot, process.cwd()) === process.cwd());
+ok("missing worktree uses directory", pickScopeRoot(null, process.cwd()) === process.cwd());
+ok("nothing but fs root: last resort", pickScopeRoot(fsRoot, null) === fsRoot);
+ok("no candidates falls back to cwd", pickScopeRoot(null, null) === process.cwd());
+
 console.log("== cjk ==");
 ok("detects han", hasCjk("中文记忆"));
 ok("detects mixed", hasCjk("open中文"));

package/scripts/test-full.ts

@@ -358,74 +358,6 @@ const inTreePage = path.join(PROJ, "page.html");
 r = cliRetry(["inventory", "--format", "html", "--out", inTreePage], PROJ);
 ok("html refuses a worktree path without --allow-personal", r.code !== 0 && !fs.existsSync(inTreePage));
 
-// ---------- 7b. D70: visibility fixes from the 3-C review ----------
-console.log("== D70: honest counts, stable numbers, one guard ==");
-// The guard must not fail open: a --out whose parent directory does not
-// exist used to skip the worktree check (git -C on a missing dir throws)
-// and then die with a raw ENOENT. Outside a worktree the missing directory
-// is the only problem left, so it gets its own message.
-const missingDir = path.join(T, "no-such-dir", "report.json");
-r = cliRetry(["inventory", "--out", missingDir], PROJ);
-ok(
-  "inventory explains a missing parent directory",
-  r.code !== 0 && /does not exist/.test(r.err) && !r.err.includes("ENOENT"),
-  (r.err || r.out).slice(0, 160),
-);
-// ...and inside a worktree the personal-content refusal wins over it.
-const missingInTree = path.join(PROJ, "no-such-dir", "report.json");
-r = cliRetry(["inventory", "--out", missingInTree], PROJ);
-ok(
-  "worktree refusal wins over a missing directory",
-  r.code !== 0 && /git working tree/.test(r.err) && !fs.existsSync(missingInTree),
-  (r.err || r.out).slice(0, 160),
-);
-
-// `open-memex list` is the surface a sceptical user runs first: it must
-// not look complete when it isn't (the tool already discloses).
-const fillerIds: string[] = [];
-for (let i = 0; i < 22; i++) fillerIds.push(addMem([`fulltest d70 filler ${i} padding text`], PROJ));
-r = cliRetry(["list", "--limit", "5"], PROJ);
-ok("cli list discloses truncation", /… and \d+ more not shown/.test(r.out), r.out.slice(-160));
-ok("cli list renders the structured inventory line", /^\d+\. \[[a-z]+\] id=\S+ created=\S+ source=/m.test(r.out), r.out.slice(0, 200));
-// Numbering runs across the whole listing, so a number names one entry.
-r = cliRetry(["list", "--scope", "both", "--limit", "5"], PROJ);
-const nums = [...r.out.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
-ok(
-  "numbers are unique and ascending across scopes",
-  nums.length > 2 && nums.every((n, i) => i === 0 || n === nums[i - 1]! + 1) && new Set(nums).size === nums.length,
-  JSON.stringify(nums),
-);
-for (const id of fillerIds) cliRetry(["forget", id], PROJ);
-
-// A retraction of an in-repo memory is a local working-tree edit until it
-// is committed - "hidden" must not read as "gone for the team".
-const repoHideId = addMem(["fulltest d70 repo retraction"], PROJ);
-cliRetry(["submit", repoHideId], PROJ);
-r = cliRetry(["forget", repoHideId, "--soft"], PROJ);
-ok(
-  "soft hide of a repo memory warns about the commit",
-  /commit and push/i.test(r.out) && /team still sees it/i.test(r.out),
-  r.out.slice(0, 200),
-);
-r = cliRetry(["forget", repoHideId], PROJ);
-
-// An empty scope must still appear: "this project has nothing" is an answer.
-const emptyProj = mkproj("empty-proj");
-r = cliRetry(["inventory", "--scope", "project"], emptyProj);
-ok("inventory shows an empty scope as 0", /Project:.*\(0\)/.test(r.out) && /nothing remembered/i.test(r.out), r.out.slice(0, 200));
-
-// JSON: no absolute local paths, and the format id records the change.
-r = cliRetry(["inventory", "--format", "json"], PROJ);
-const invJson2 = JSON.parse(r.out.slice(r.out.indexOf("{")));
-ok(
-  "inventory json is /2 and carries no absolute file paths",
-  invJson2.format === "open-memex-inventory/2" &&
-    !JSON.stringify(invJson2).includes(TESTENV.MY_O_MEMORY_HOME as string) &&
-    !/"file":/.test(JSON.stringify(invJson2)),
-  `${invJson2.format} ${JSON.stringify(invJson2).slice(0, 120)}`,
-);
-ok("inventory json counts hidden without the entries", invJson2.hidden !== undefined && !("hiddenEntries" in invJson2));
-
 // ---------- 8. pull / push ----------
 console.log("== pull / push ==");
 r = cliRetry(["push"], PROJ);
@@ -696,6 +628,147 @@ console.log("== D64: p1 fixes (propose visibility / supersede published / status
   ok("uninstall finds and cleans .jsonc global config", r.code === 0 && !/open-memex/.test(afterText), (r.out + r.err).slice(0, 160) + " || " + afterText.slice(0, 120));
 }
 
+// ---------- 12. D70: the visibility fixes from the 3-C review ----------
+// Last section on purpose: nothing here may perturb the flows above it.
+// It writes only into a scratch project and into appdata fixtures (no
+// commits in PROJ, no extra CLI spawns beyond a handful) so the suite stays
+// order-independent and cheap — the shared PROJ git state is never dirtied.
+console.log("== D70: honest counts, stable numbers, one guard ==");
+{
+  const fixture = (dir: string, id: string, body: string, scopeKey: string) => {
+    const now = new Date().toISOString();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, `${id}.md`),
+      `---
+id: ${id}
+schema_version: 2
+scope_key: ${scopeKey}
+scope: project
+visibility: internal
+project_name: d70
+type: fact
+role: knowledge
+importance: normal
+status: active
+tags: []
+source: cli
+created_at: "${now}"
+updated_at: "${now}"
+supersedes: null
+superseded_by: null
+review_state: draft
+proposed_by: null
+approved_by: null
+derived_from: null
+review_note: null
+review_history: []
+---
+
+${body}
+`,
+      "utf8",
+    );
+  };
+
+  // The guard must not fail open: a --out whose parent directory does not
+  // exist used to skip the worktree check (git -C on a missing dir throws)
+  // and then die with a raw ENOENT. Outside a worktree the missing directory
+  // is the only problem left, so it gets its own message.
+  const missingDir = path.join(T, "no-such-dir", "report.json");
+  r = cliRetry(["inventory", "--out", missingDir], PROJ);
+  ok(
+    "inventory explains a missing parent directory",
+    r.code !== 0 && /does not exist/.test(r.err) && !r.err.includes("ENOENT"),
+    (r.err || r.out).slice(0, 160),
+  );
+  // ...and inside a worktree the personal-content refusal wins over it.
+  const missingInTree = path.join(PROJ, "no-such-dir", "report.json");
+  r = cliRetry(["inventory", "--out", missingInTree], PROJ);
+  ok(
+    "worktree refusal wins over a missing directory",
+    r.code !== 0 && /git working tree/.test(r.err) && !fs.existsSync(missingInTree),
+    (r.err || r.out).slice(0, 160),
+  );
+
+  // `open-memex list` is the surface a sceptical user runs first: it must
+  // not look complete when it isn't. Fixtures go straight into the outbox
+  // (appdata, never the repo), so this needs no commits and no cleanup in git.
+  const d70Key = (/project:\s*(\S+)/.exec(cli(["where"], PROJ).out) || [])[1] ?? "";
+  const outboxDir = path.join(TESTENV.MY_O_MEMORY_HOME as string, "memories", d70Key);
+  const fillerIds: string[] = [];
+  for (let i = 0; i < 22; i++) {
+    const cid = `01P1D70${String(i).padStart(19, "0")}`;
+    fillerIds.push(cid);
+    fixture(outboxDir, cid, `fulltest d70 filler ${i} padding text`, d70Key);
+  }
+  cli(["reindex"], PROJ);
+  r = cliRetry(["list", "--limit", "5"], PROJ);
+  ok("cli list discloses truncation", /… and \d+ more not shown/.test(r.out), r.out.slice(-160));
+  ok(
+    "cli list renders the structured inventory line",
+    /^\d+\. \[[a-z]+\] id=\S+ created=\S+ source=/m.test(r.out),
+    r.out.slice(0, 200),
+  );
+  // Numbering runs across the whole listing, so a number names one entry.
+  r = cliRetry(["list", "--scope", "both", "--limit", "5"], PROJ);
+  const nums = [...r.out.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
+  ok(
+    "numbers are unique and ascending across scopes",
+    nums.length > 2 && new Set(nums).size === nums.length && nums[0] === 1 && nums.every((n, i) => i === 0 || n === nums[i - 1]! + 1),
+    JSON.stringify(nums),
+  );
+  // The text report numbers the same way.
+  r = cliRetry(["inventory", "--scope", "project"], PROJ);
+  const textNums = [...r.out.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
+  ok(
+    "inventory text numbers continuously too",
+    textNums.length > 2 && new Set(textNums).size === textNums.length && textNums.every((n, i) => i === 0 || n === textNums[i - 1]! + 1),
+    JSON.stringify(textNums.slice(0, 8)),
+  );
+  for (const id of fillerIds) fs.rmSync(path.join(outboxDir, `${id}.md`), { force: true });
+  cli(["reindex"], PROJ);
+
+  // A retraction of an in-repo memory is a local working-tree edit until it
+  // is committed - "hidden" must not read as "gone for the team". Runs in its
+  // own project so PROJ's git state stays clean for the sections above.
+  const d70Proj = mkproj("d70-proj");
+  const repoHideId = addMem(["fulltest d70 repo retraction"], d70Proj);
+  cliRetry(["submit", repoHideId], d70Proj);
+  r = cliRetry(["forget", repoHideId, "--soft"], d70Proj);
+  ok(
+    "soft hide of a repo memory warns about the commit",
+    /commit and push/i.test(r.out) && /team still sees it/i.test(r.out),
+    r.out.slice(0, 200),
+  );
+  r = cliRetry(["forget", repoHideId], d70Proj);
+  ok("hard forget of a hidden repo memory still deletes", r.code === 0 && /deleted/i.test(r.out), (r.err || r.out).slice(0, 120));
+
+  // An empty scope must still appear: "this project has nothing" is an answer.
+  const emptyProj = mkproj("empty-proj");
+  r = cliRetry(["inventory", "--scope", "project"], emptyProj);
+  ok(
+    "inventory shows an empty scope as 0",
+    /Project:.*\(0\)/.test(r.out) && /nothing remembered/i.test(r.out),
+    r.out.slice(0, 200),
+  );
+
+  // JSON: no absolute local paths, and the format id records the change.
+  r = cliRetry(["inventory", "--format", "json"], PROJ);
+  const invJson2 = JSON.parse(r.out.slice(r.out.indexOf("{")));
+  ok(
+    "inventory json is /2 and carries no absolute file paths",
+    invJson2.format === "open-memex-inventory/2" &&
+      !JSON.stringify(invJson2).includes(TESTENV.MY_O_MEMORY_HOME as string) &&
+      !/"file":/.test(JSON.stringify(invJson2)),
+    `${invJson2.format} ${JSON.stringify(invJson2).slice(0, 120)}`,
+  );
+  ok(
+    "inventory json counts hidden without the entries",
+    invJson2.hidden !== undefined && !("hiddenEntries" in invJson2),
+  );
+}
+
 console.log("\n================ SUMMARY ================");
 console.log(`pass: ${pass}, fail: ${fail}`);
 if (failures.length) { console.log("failed tests:"); for (const f of failures) console.log("  - " + f); }

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   captureFromText,
   injectOnce,
 } from "./plugin-core.ts";
+import { pickScopeRoot } from "./scope.ts";
 import { makeTools } from "./tools/memory.ts";
 import { v2Plugin } from "./opencode-v2.ts";
 
@@ -19,8 +20,9 @@ import { v2Plugin } from "./opencode-v2.ts";
  * type-only (D58), and v2's decode is structural.
  */
 const server: Plugin = async ({ worktree, directory }) => {
-  const roots = worktree || directory || process.cwd();
-  const state = bootstrapPlugin(roots);
+  // v1's `worktree` is the filesystem root for non-git folders — never seed a
+  // scope on it (D71). `pickScopeRoot` falls back to the opened `directory`.
+  const state = bootstrapPlugin(pickScopeRoot(worktree, directory));
   const tools = makeTools(() => state.scope, state.cfg);
 
   return {

package/src/scope.ts

@@ -68,6 +68,24 @@ export function resolveCwdScope(worktree: string): Scope {
   return scopeFromSeed(seed, projectName);
 }
 
+/** Pick the directory that seeds scope resolution from a host's candidate
+ *  roots. OpenCode v1 hands the plugin both `worktree` (the repo root — but
+ *  the filesystem root, e.g. `C:\` or `/`, when the opened folder is not a
+ *  git repo) and `directory` (the folder actually opened). Seeding on a
+ *  filesystem root collapses every non-git folder on a drive into one shared
+ *  `project__workspace__…` scope (D71), so prefer `worktree` only when it is
+ *  a real directory below the filesystem root. */
+export function pickScopeRoot(
+  worktree?: string | null,
+  directory?: string | null,
+): string {
+  const isFsRoot = (p: string) => path.parse(p).root === p;
+  if (worktree && !isFsRoot(worktree)) return worktree;
+  if (directory) return directory;
+  if (worktree) return worktree;
+  return process.cwd();
+}
+
 export function resolveProjectScope(worktree: string): Scope {
   const target = worktree && worktree.length > 0 ? worktree : ".";
   const remote = tryGitRemote(target);