opencode-memory-pro 1.3.5 → 1.3.7

package/README.md

@@ -40,7 +40,7 @@ Published on npm — install directly (requires OpenCode ≥ 1.x and Node.js ≥
 opencode plugin opencode-memory-pro
 ```
 
-The latest release is **v1.3.5** on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
+The latest release is **v1.3.7** on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
 
 Remove the old plugin pin at the same time:
 
@@ -408,6 +408,52 @@ so your memories and graph carry over untouched.
 
 ## Changelog
 
+### v1.3.7 (2026-09-06)
+
+Scope normalization — fixes lost memories when a `scope` argument is
+explicitly passed to a tool while `scoping` is `"global"`:
+
+- **Explicit scopes now collapse to `global` in global mode**: previously
+  `memory_remember(scope="project")` (and every other tool accepting a `scope`
+  arg) stored the row under the literal string `"project"` — but scope-filtered
+  reads derive the scope via `deriveProjectScope()`, which returns `"global"`
+  in global mode, so the memory was effectively lost (invisible to search,
+  promote, why, `memory_global_list`, ...; reachable only by passing
+  `scope="project"` explicitly).
+- **New `resolveScope(scope, worktree)` helper** in `dist/scope.js` — collapses
+  any explicit scope to `"global"` in global mode and honors it in project
+  mode (falling back to the derived project scope when omitted). Applied to all
+  30 scope-arg sites across `dist/tools/memory.js`, `dist/tools/episodic.js`,
+  and `dist/tools/feedback.js`, including `memory_clear`, which previously
+  called `clearScope(args.scope)` without any normalization.
+- **Tests**: two new unit tests cover the collapse-to-global and
+  honor-in-project-mode behavior.
+
+### v1.3.6 (2026-09-06)
+
+Compaction lock hardening — fixes the "Compaction commit failed; leaving N
+rewritten fragment(s) in place for GC" warning reappearing on the TUI at
+startup / first turn when two opencode instances share one store:
+
+- **No more lock stealing during the owner's init window**: the owner creates
+  `.optimize.lock` with `open("wx")` and *then* writes its pid; a contender
+  reading in between saw an empty file, declared it stale, deleted it, and
+  created its own — so both processes "owned" the lock and raced `optimize()`
+  (the native LanceDB stderr line is uninterceptable by the plugin). The lock
+  now treats an empty file as "being initialized" for a short grace instead of
+  reclaiming it.
+- **Contenders wait instead of giving up instantly**: when a live process holds
+  the lock, the second instance now polls up to 10s for it to finish (serializing
+  compaction across processes) before skipping this cycle and retrying next
+  interval, instead of racing it.
+- **In-process guard set synchronously**: `maybeOptimizeAll` now sets
+  `optimizing = true` before any `await`, so overlapping calls in one process
+  (fire-and-forget write trigger + awaited explicit call on the first turn)
+  can no longer both run `optimize()` concurrently.
+- **Tests**: two new unit tests cover the open→write TOCTOU (old lock returns
+  `true` and steals; new lock returns `false` and preserves ownership) and
+  stale-lock reclamation.
+
 ### v1.3.5 (2026-09-06)
 
 Code-review hardening pass — bug fixes, no breaking changes:

package/dist/index.js

@@ -11,7 +11,7 @@ import { requestLLMCapture, isOwnSession } from "./llm.js";
 import { createMemoryTools, createFeedbackTools, createEpisodicTools } from "./tools/index.js";
 import { sweepExpiredMemories } from "./tools/memory.js";
 import { createGraphStore } from "./graph.js";
-const PLUGIN_VERSION = "1.3.5";
+const PLUGIN_VERSION = "1.3.7";
 const SCHEMA_VERSION = 1;
 // Event-driven dedup: run consolidateDuplicates on session.idle (throttled to
 // this interval so chatty sessions aren't re-scanning the store every turn)

package/dist/scope.js

@@ -26,6 +26,18 @@ export function buildScopeFilter(activeScope, includeGlobal) {
     const scopes = includeGlobal ? [activeScope, "global"] : [activeScope];
     return [...new Set(scopes)];
 }
+// SCOPE_NORMALIZE (1.3.7): resolves a caller-supplied scope argument against
+// the active scoping mode. In "global" mode every explicit scope (e.g. a
+// memory_remember(scope="project")) collapses to "global" — otherwise such
+// rows would be stored under a literal scope that scope-filtered tools never
+// query (the rows are effectively lost). In "project" mode the argument is
+// honored, falling back to the derived project scope.
+export function resolveScope(scope, worktree) {
+    if (resolveScoping(worktree) !== "project") {
+        return "global";
+    }
+    return scope ?? deriveProjectScope(worktree);
+}
 function resolveScoping(worktree) {
     try {
         return resolveMemoryConfig({}, worktree).scoping === "project" ? "project" : "global";

package/dist/store.js

@@ -78,6 +78,17 @@ export class MemoryStore {
     // skips this cycle (the 6h interval retries later). Stale locks (owner
     // process dead or older than the TTL) are reclaimed.
     static OPTIMIZE_LOCK_TTL_MS = 30 * 60 * 1000;
+    // OPTIMIZE_LOCK_WAIT (1.3.6): the 1.3.4 lock gave up instantly when a live
+    // process held it, and worse, it treated an EMPTY lock file as stale and
+    // deleted it. But the owner creates the file with open("wx") and only THEN
+    // writes its pid — a reader landing in that window read 0 bytes, declared
+    // the lock stale, deleted it, and both processes "owned" the lock and raced
+    // optimize(), which is what puts "Compaction commit failed; leaving N
+    // rewritten fragments in place for GC" back on the TUI. Now a contender
+    // WAITS a bounded amount of time for a live owner to finish (serializing
+    // the compaction), and only reclaims after the pid should have been
+    // written or the 30min TTL passes.
+    static OPTIMIZE_LOCK_WAIT_MS = 10 * 1000;
     optimizing = false;
     lastOptimizeAt = 0;
     constructor(dbPath, cacheConfig) {
@@ -94,7 +105,9 @@ export class MemoryStore {
     async acquireOptimizeLock() {
         await mkdir(this.dbPath, { recursive: true }).catch(() => { });
         const lockFile = join(this.dbPath, ".optimize.lock");
-        for (let attempt = 0; attempt < 2; attempt += 1) {
+        const deadline = Date.now() + MemoryStore.OPTIMIZE_LOCK_WAIT_MS;
+        let waitedMs = 0;
+        for (;;) {
             try {
                 const handle = await open(lockFile, "wx");
                 try {
@@ -102,6 +115,9 @@ export class MemoryStore {
                 }
                 catch { }
                 await handle.close();
+                if (waitedMs > 0) {
+                    log("debug", `[store] acquired compaction lock after ${waitedMs}ms wait`);
+                }
                 return true;
             }
             catch (error) {
@@ -114,6 +130,16 @@ export class MemoryStore {
                     const ownerPid = Number(pidStr);
                     const ownerTs = Number(tsStr);
                     if (!Number.isInteger(ownerPid) || ownerPid <= 0) {
+                        // The owner creates the file with open("wx") and only
+                        // THEN writes the pid; reading in between yields empty
+                        // content. Treat that as "being initialized", not stale
+                        // — this was the 1.3.4 bug that let two instances both
+                        // own the lock and race optimize().
+                        if (waitedMs < 250) {
+                            await new Promise((resolve) => setTimeout(resolve, 50));
+                            waitedMs += 50;
+                            continue;
+                        }
                         stale = true;
                     }
                     else if (Number.isFinite(ownerTs) && Date.now() - ownerTs > MemoryStore.OPTIMIZE_LOCK_TTL_MS) {
@@ -127,16 +153,37 @@ export class MemoryStore {
                             stale = true;
                         }
                     }
+                    else {
+                        // Same process already owns it (shouldn't happen with
+                        // the optimizing guard; never deadlock on ourselves).
+                        return false;
+                    }
                 }
                 catch {
+                    // Lock vanished between the EEXIST and the read (owner
+                    // released); give it a short grace before reclaiming.
+                    if (waitedMs < 150) {
+                        await new Promise((resolve) => setTimeout(resolve, 50));
+                        waitedMs += 50;
+                        continue;
+                    }
                     stale = true;
                 }
-                if (!stale)
-                    return false;
+                if (!stale) {
+                    // Live owner: wait for it to finish instead of racing it,
+                    // until the bounded deadline (then skip this cycle).
+                    if (Date.now() >= deadline) {
+                        logFileOnly("debug", "[store] compaction lock still held after waiting; skipping this cycle");
+                        return false;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    waitedMs += 100;
+                    continue;
+                }
+                // Stale: reclaim and loop back to try creating the lock.
                 await rm(lockFile, { force: true }).catch(() => { });
             }
         }
-        return false;
     }
     async releaseOptimizeLock() {
         await rm(join(this.dbPath, ".optimize.lock"), { force: true }).catch(() => { });
@@ -155,42 +202,51 @@ export class MemoryStore {
     async maybeOptimizeAll(force = false) {
         if (this.optimizing)
             return;
-        const elapsed = Date.now() - this.lastOptimizeAt;
-        if (!force && elapsed < MemoryStore.OPTIMIZE_INTERVAL_MS)
-            return;
-        const tables = [this.table, this.eventTable, this.episodicTaskTable].filter(Boolean);
-        const candidates = [];
-        for (const table of tables) {
-            let count = 0;
-            // LANCE_COMPACTION_FIX (1.1.6): LanceDB stores each table on disk as
-            // "<name>.lance", but Table.name only carries the bare name — so the
-            // old readdir(.../table.name/_versions) always hit ENOENT, the catch
-            // swallowed it, and optimize() NEVER ran. Result: 13k+ _versions and
-            // 11k+ fragment files accumulated (disk + native handle/cache growth
-            // per write, EMFILE/OOM risk). Try the real on-disk dir first.
-            for (const dirName of [`${table.name}.lance`, table.name]) {
-                try {
-                    const entries = await readdir(join(this.dbPath, dirName, "_versions"), { withFileTypes: true });
-                    count = entries.filter((e) => e.isFile()).length;
-                    if (count > 0)
-                        break;
+        // OPTIMIZE_GUARD (1.3.6): set the in-process guard synchronously,
+        // BEFORE any await. The 1.3.4 code set it only after the async
+        // candidate enumeration, so two overlapping calls in one process (the
+        // fire-and-forget write trigger plus an awaited explicit call on the
+        // first turn) could both pass the guard and run optimize()
+        // concurrently — another way into the "Compaction commit failed" race.
+        this.optimizing = true;
+        let attempted = false;
+        try {
+            const elapsed = Date.now() - this.lastOptimizeAt;
+            if (!force && elapsed < MemoryStore.OPTIMIZE_INTERVAL_MS)
+                return;
+            const tables = [this.table, this.eventTable, this.episodicTaskTable].filter(Boolean);
+            const candidates = [];
+            for (const table of tables) {
+                let count = 0;
+                // LANCE_COMPACTION_FIX (1.1.6): LanceDB stores each table on disk as
+                // "<name>.lance", but Table.name only carries the bare name — so the
+                // old readdir(.../table.name/_versions) always hit ENOENT, the catch
+                // swallowed it, and optimize() NEVER ran. Result: 13k+ _versions and
+                // 11k+ fragment files accumulated (disk + native handle/cache growth
+                // per write, EMFILE/OOM risk). Try the real on-disk dir first.
+                for (const dirName of [`${table.name}.lance`, table.name]) {
+                    try {
+                        const entries = await readdir(join(this.dbPath, dirName, "_versions"), { withFileTypes: true });
+                        count = entries.filter((e) => e.isFile()).length;
+                        if (count > 0)
+                            break;
+                    }
+                    catch { }
+                }
+                if (force || count >= MemoryStore.OPTIMIZE_MIN_VERSIONS) {
+                    candidates.push({ table, count });
+                }
+                else {
+                    log("debug", `[store] optimize skipped for ${table.name}: ${count} versions (min ${MemoryStore.OPTIMIZE_MIN_VERSIONS})`);
                 }
-                catch { }
-            }
-            if (force || count >= MemoryStore.OPTIMIZE_MIN_VERSIONS) {
-                candidates.push({ table, count });
             }
-            else {
-                log("debug", `[store] optimize skipped for ${table.name}: ${count} versions (min ${MemoryStore.OPTIMIZE_MIN_VERSIONS})`);
+            if (force) {
+                this.lastOptimizeAt = Date.now();
+                attempted = true;
             }
-        }
-        if (force) {
-            this.lastOptimizeAt = Date.now();
-        }
-        if (candidates.length === 0)
-            return;
-        this.optimizing = true;
-        try {
+            if (candidates.length === 0)
+                return;
+            attempted = true;
             const lockHeld = await this.acquireOptimizeLock();
             if (!lockHeld) {
                 logFileOnly("warn", "[store] optimize skipped: another process holds the compaction lock (retries next interval)");
@@ -226,7 +282,9 @@ export class MemoryStore {
         }
         finally {
             this.optimizing = false;
-            this.lastOptimizeAt = Date.now();
+            if (attempted) {
+                this.lastOptimizeAt = Date.now();
+            }
         }
     }
     async init(vectorDim) {

package/dist/tools/episodic.js

@@ -1,5 +1,5 @@
 import { tool } from "@opencode-ai/plugin";
-import { deriveProjectScope } from "../scope.js";
+import { deriveProjectScope, resolveScope } from "../scope.js";
 import { generateId, parseJsonObject } from "../utils.js";
 function unavailableMessage(provider) {
     return `Memory store unavailable (${provider} embedding may be offline). Will retry automatically.`;
@@ -17,7 +17,7 @@ export function createEpisodicTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const episode = {
                     id: generateId(),
                     sessionId: context.sessionID,
@@ -48,7 +48,7 @@ export function createEpisodicTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const stateFilter = args.state;
                 const episodes = await state.store.queryTaskEpisodes(activeScope, stateFilter);
                 if (episodes.length === 0) {
@@ -73,7 +73,7 @@ export function createEpisodicTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 let queryVector = [];
                 try {
                     queryVector = await state.embedder.embed(args.query);
@@ -107,7 +107,7 @@ export function createEpisodicTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const result = await state.store.suggestRetryBudget(activeScope, args.minSamples ?? 3);
                 if (!result) {
                     return `Insufficient data for retry budget suggestion (need at least ${args.minSamples} failed tasks)`;
@@ -131,7 +131,7 @@ export function createEpisodicTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const strategies = await state.store.suggestRecoveryStrategies(activeScope, args.taskId);
                 if (strategies.length === 0) {
                     return `No recovery strategies found for task ${args.taskId}`;

package/dist/tools/feedback.js

@@ -1,5 +1,5 @@
 import { tool } from "@opencode-ai/plugin";
-import { deriveProjectScope, buildScopeFilter } from "../scope.js";
+import { deriveProjectScope, buildScopeFilter, resolveScope } from "../scope.js";
 import { generateId } from "../utils.js";
 function unavailableMessage(provider) {
     return `Memory store unavailable (${provider} embedding may be offline). Will retry automatically.`;
@@ -17,7 +17,7 @@ export function createFeedbackTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 await state.store.putEvent({
                     id: generateId(),
                     type: "feedback",
@@ -43,7 +43,7 @@ export function createFeedbackTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(scope, state.config.includeGlobalScope);
                 const exists = await state.store.hasMemory(args.id, scopes);
                 if (!exists) {
@@ -74,7 +74,7 @@ export function createFeedbackTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(scope, state.config.includeGlobalScope);
                 const exists = await state.store.hasMemory(args.id, scopes);
                 if (!exists) {
@@ -103,7 +103,7 @@ export function createFeedbackTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const summary = await state.store.summarizeEvents(scope, state.config.includeGlobalScope);
                 return JSON.stringify(summary, null, 2);
             },

package/dist/tools/memory.js

@@ -1,5 +1,5 @@
 import { tool } from "@opencode-ai/plugin";
-import { deriveProjectScope, buildScopeFilter } from "../scope.js";
+import { deriveProjectScope, buildScopeFilter, resolveScope } from "../scope.js";
 import { generateId } from "../utils.js";
 import { getEmbedderHealth } from "../embedder.js";
 import { extractiveDigest, retentionCandidates } from "../store.js";
@@ -43,7 +43,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 let queryVector = [];
                 let embedderFailed = false;
@@ -208,7 +208,7 @@ export function createMemoryTools(state) {
                 if (!args.confirm) {
                     return "Rejected: memory_delete requires confirm=true.";
                 }
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const deleted = await state.store.deleteById(args.id, scopes);
                 return deleted ? `Deleted memory ${args.id}.` : `Memory ${args.id} not found in current scope.`;
@@ -220,15 +220,16 @@ export function createMemoryTools(state) {
                 scope: tool.schema.string(),
                 confirm: tool.schema.boolean().default(false),
             },
-            execute: async (args) => {
+            execute: async (args, context) => {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
                 if (!args.confirm) {
                     return "Rejected: destructive clear requires confirm=true.";
                 }
-                const count = await state.store.clearScope(args.scope);
-                return `Cleared ${count} memories from scope ${args.scope}.`;
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
+                const count = await state.store.clearScope(activeScope);
+                return `Cleared ${count} memories from scope ${activeScope}.`;
             },
         }),
         memory_stats: tool({
@@ -240,7 +241,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const entries = await state.store.list(scope, 20);
                 const incompatibleVectors = await state.store.countIncompatibleVectors(buildScopeFilter(scope, state.config.includeGlobalScope), await state.embedder.dim());
                 const health = state.store.getIndexHealth();
@@ -303,7 +304,7 @@ export function createMemoryTools(state) {
                 // passed `args.scope` to cleanupExpiredEvents where `undefined`
                 // meant ALL scopes (and the store's `scope LIKE 'project:%'`
                 // matched every project scope).
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const cutoffTimestamp = Date.now() - status.retentionDays * 24 * 60 * 60 * 1000;
                 if (args.dryRun) {
@@ -370,7 +371,7 @@ export function createMemoryTools(state) {
                 if (args.text.length < state.config.minCaptureChars) {
                     return `Content too short (minimum ${state.config.minCaptureChars} characters).`;
                 }
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 let vector = [];
                 try {
                     vector = await state.embedder.embed(args.text);
@@ -443,7 +444,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 if (args.force) {
                     const deleted = await state.store.deleteById(args.id, scopes);
@@ -499,7 +500,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const citation = await state.store.getCitation(args.id, scopes);
                 if (!citation) {
@@ -535,7 +536,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const result = await state.store.validateCitation(args.id, scopes);
                 return JSON.stringify({
@@ -556,7 +557,7 @@ export function createMemoryTools(state) {
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const sinceTimestamp = Date.now() - (args.days ?? 7) * 24 * 60 * 60 * 1000;
                 const memories = await state.store.listSince(activeScope, sinceTimestamp, 1000);
                 if (memories.length === 0) {
@@ -598,7 +599,7 @@ ${recentSamples}
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const explanation = await state.store.explainMemory(args.id, scopes, activeScope, state.config.retrieval.recencyHalfLifeHours, state.config.globalDiscountFactor);
                 if (!explanation) {
@@ -637,7 +638,7 @@ Explanation:
                 if (!lastRecall) {
                     return "No recent recall to explain. Use memory_search or wait for auto-recall first.";
                 }
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const explanations = [];
                 for (const result of lastRecall.results) {
@@ -697,7 +698,7 @@ ${explanations.join("\n")}`;
                 if (!args.confirm) {
                     return "Rejected: memory_scope_demote requires confirm=true.";
                 }
-                const projectScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const projectScope = resolveScope(args.scope, context.directory || context.worktree);
                 const globalExists = await state.store.hasMemory(args.id, ["global"]);
                 if (!globalExists) {
                     return `Memory ${args.id} not found in global scope or is not a global memory.`;
@@ -774,7 +775,7 @@ ${explanations.join("\n")}`;
                 if (!args.confirm) {
                     return "Rejected: memory_consolidate requires confirm=true.";
                 }
-                const targetScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const targetScope = resolveScope(args.scope, context.directory || context.worktree);
                 if (state.consolidationInProgress.get(targetScope)) {
                     return JSON.stringify({ scope: targetScope, status: "already_in_progress", message: "Consolidation already in progress for this scope" });
                 }
@@ -980,7 +981,7 @@ ${explanations.join("\n")}`;
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const dashboard = await state.store.getWeeklyEffectivenessSummary(scope, state.config.includeGlobalScope, args.days ?? 7);
                 return JSON.stringify(dashboard, null, 2);
             },
@@ -995,7 +996,7 @@ ${explanations.join("\n")}`;
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const scope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const scope = resolveScope(args.scope, context.directory || context.worktree);
                 const kpi = await state.store.getKpiSummary(scope, args.days ?? 30);
                 return JSON.stringify(kpi, null, 2);
             },
@@ -1012,7 +1013,7 @@ ${explanations.join("\n")}`;
                 await state.ensureInitialized();
                 if (!state.initialized)
                     return unavailableMessage(state.config.embedding.provider);
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const records = await state.store.exportAllRecords(scopes);
                 if (args.dryRun) {
@@ -1073,7 +1074,7 @@ ${explanations.join("\n")}`;
                 if (!Array.isArray(payload?.memories)) {
                     return JSON.stringify({ error: "Not a memory_export backup (missing memories array)" }, null, 2);
                 }
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const source = payload?.memories ?? [];
                 let imported = 0;
@@ -1203,7 +1204,7 @@ ${explanations.join("\n")}`;
                 if (summarizeCfg.enabled === false) {
                     return JSON.stringify({ error: "Summarization disabled via config summarize.enabled=false" }, null, 2);
                 }
-                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const activeScope = resolveScope(args.scope, context.directory || context.worktree);
                 const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                 const minAgeDays = args.minAgeDays ?? summarizeCfg.minAgeDays;
                 const minGroupSize = args.minGroupSize ?? summarizeCfg.minGroupSize;
@@ -1347,7 +1348,7 @@ ${explanations.join("\n")}`;
                     return JSON.stringify({ error: "Memory retention disabled via config retention.memory.enabled=false" }, null, 2);
                 }
                 const result = await sweepExpiredMemories(state, {
-                    scope: args.scope ?? deriveProjectScope(context.directory || context.worktree),
+                    scope: resolveScope(args.scope, context.directory || context.worktree),
                     dryRun: args.dryRun === true,
                     unusedDays: args.unusedDays,
                     minAgeDays: args.minAgeDays,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memory-pro",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "LanceDB-backed long-term memory provider for OpenCode — standalone fork of lancedb-opencode-pro with entity graph, lifecycle, and retention",
   "type": "module",
   "main": "dist/index.js",