opencode-memory-pro 1.3.6 → 1.3.8

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.8** 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,68 @@ so your memories and graph carry over untouched.
 
 ## Changelog
 
+### v1.3.8 (2026-09-06)
+
+Fixes `memory_forget(force=true)` being unable to permanently delete a memory
+that was soft-deleted first:
+
+- **Force delete now sees hidden rows**: `softDeleteMemory` marks a row
+  `status='disabled'`, and the force path previously used `deleteById`, whose
+  `readByScopes` query filters out `status='disabled'` (and `merged`/`digested`)
+  rows — so "Use force=true for permanent deletion" silently failed and left
+  the hidden row on disk forever. The force path now uses the new
+  `deleteByIdForce` in `dist/store.js`, which tries the exact-id raw delete
+  first and otherwise scans unfiltered rows (so id prefixes still match).
+- **Tests**: integration test covers the exact scenario — soft-delete, confirm
+  the old path returns `false`, then `deleteByIdForce` removes the row and
+  reports `false` on a second attempt.
+
+### 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.6";
+const PLUGIN_VERSION = "1.3.8";
 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.d.ts

@@ -49,6 +49,8 @@ export declare class MemoryStore {
         globalDiscountFactor?: number;
     }): Promise<SearchResult[]>;
     deleteById(id: string, scopes: string[]): Promise<boolean>;
+    deleteByIdRaw(id: string): Promise<boolean>;
+    deleteByIdForce(id: string): Promise<boolean>;
     softDeleteMemory(id: string, scopes: string[]): Promise<boolean>;
     updateMemoryScope(id: string, newScope: string, scopes: string[]): Promise<boolean>;
     readGlobalMemories(limit?: number): Promise<MemoryRecord[]>;

package/dist/store.js

@@ -628,6 +628,28 @@ export class MemoryStore {
         this.notifyGraphRemoved(id);
         return true;
     }
+    // DELETE_BY_FORCE (1.3.8): like deleteById but sees rows the status-
+    // filtered reads hide (disabled/merged/digested). Fixes memory_forget
+    // force=true: the soft-delete path marks rows disabled, and the force
+    // path previously used deleteById, whose readByScopes filter excludes
+    // status='disabled' — so "Use force=true for permanent deletion" silently
+    // failed and left the hidden row on disk forever. Tries the exact-id raw
+    // delete first (fast path), then falls back to an unfiltered scan so
+    // prefix ids and hidden rows both work.
+    async deleteByIdForce(id) {
+        if (await this.deleteByIdRaw(id)) {
+            return true;
+        }
+        const table = this.requireTable();
+        const rows = await table.query().limit(100000).toArray();
+        const match = rows.find((row) => this.matchesId(row.id, id));
+        if (!match)
+            return false;
+        await table.delete(`id = '${escapeSql(match.id)}'`);
+        this.invalidateScope(match.scope);
+        this.notifyGraphRemoved(match.id);
+        return true;
+    }
     async softDeleteMemory(id, scopes) {
         const rows = await this.readByScopes(scopes);
         const match = rows.find((row) => this.matchesId(row.id, id));

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,10 +444,14 @@ 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);
+                    // FORCE_DELETE_HIDDEN (1.3.8): was deleteById, whose
+                    // readByScopes filter excludes disabled/merged rows — so
+                    // force=true could never permanently delete a memory that
+                    // was soft-deleted first.
+                    const deleted = await state.store.deleteByIdForce(args.id);
                     if (!deleted) {
                         return `Memory ${args.id} not found in current scope.`;
                     }
@@ -499,7 +504,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 +540,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 +561,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 +603,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 +642,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 +702,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 +779,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 +985,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 +1000,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 +1017,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 +1078,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 +1208,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 +1352,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.6",
+  "version": "1.3.8",
   "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",