opencode-memory-pro 1.3.4 → 1.3.6

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.3** 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.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).
 
 Remove the old plugin pin at the same time:
 
@@ -406,6 +406,47 @@ Clean-break rename: sidecar is `opencode-memory-pro.json`, env prefix is
 are unchanged (`~/.opencode/memory/lancedb` + `~/.opencode/memory/graph.db`),
 so your memories and graph carry over untouched.
 
+## Changelog
+
+### v1.3.5 (2026-09-06)
+
+Code-review hardening pass — bug fixes, no breaking changes:
+
+- **Metadata is no longer destroyed on recall** (`updateMemoryUsage`): the
+  first recall of a global memory used to *replace* `metadataJson` with
+  `{ recalledProjects: [...] }`, silently dropping `pinned`, duplicate flags,
+  source, and graph entities — breaking `memory_export` provenance, duplicate-
+  aware pruning, and the pin protection in retention. It now merges into the
+  existing metadata blob.
+- **LLM capture respects an explicit "nothing to store" verdict**: when the LLM
+  extraction succeeds but returns `[]`, the transcript no longer falls through
+  to the keyword heuristics and gets stored against the model's judgment — the
+  heuristic fallback now only runs when extraction actually fails.
+- **Ephemeral LLM sessions no longer trigger consolidate/sweep**: the
+  `session.deleted` cleanup ran unconditionally with `force=true`, so in
+  `capture.mode="llm"` every ephemeral extraction/digest session paid a full
+  dedup + retention scan on teardown (and could spawn further LLM digests).
+  Own sessions are skipped entirely; pending transcript fragments are flushed
+  before user sessions close.
+- **Consolidation only merges active memories**: digested (retention-hidden)
+  and disabled (soft-deleted) rows can no longer be picked as merge endpoints,
+  which previously flipped their status to `merged` and could resurrect
+  disabled memories / corrupt digest provenance.
+- **`memory_import` replace-mode can't duplicate ids**: existence is now
+  checked against raw rows (digested/merged/disabled included) and replace
+  deletes the exact id before re-adding, so a hidden row is truly replaced
+  instead of leaving two physical rows per id. Citation chains are also
+  stringified consistently on write.
+- **Episodic data is actually recorded**: failed validations now write numbered
+  retry attempts (so `retry_budget_suggest` has real data), and sessions that
+  receive injected memories are stamped `recallUsed` (so `memory_kpi`'s memory
+  lift is meaningful).
+- **Smaller fixes**: `session.error` session-id fallback (`info.id`), bounded
+  `getEventTtlStatus` read, graph backfill covers all scopes, embedder
+  `fallbackActive` resets on recovery, scope-cache truncation is logged,
+  `memory_forget` records `wrong` feedback instead of polluting unhelpful
+  stats.
+
 ## License
 
 MIT — fork of `lancedb-opencode-pro` (MIT, tryweb).

package/dist/embedder.js

@@ -42,6 +42,10 @@ async function embedWithRetry(embedder, config, text) {
             const result = await embedder.embed(text);
             globalEmbedderHealth.lastSuccess = Date.now();
             globalEmbedderHealth.lastError = null;
+            // EMBEDDER_HEALTH_RESET (1.3.5): fallbackActive used to stay true
+            // forever after one outage, so memory_stats reported "bm25-only"
+            // even after the provider recovered. Reset it on any success.
+            globalEmbedderHealth.fallbackActive = false;
             if (globalEmbedderHealth.status === "degraded") {
                 globalEmbedderHealth.status = "healthy";
                 log("info", "Embedder recovered, resuming normal mode");
@@ -83,6 +87,7 @@ async function dimWithRetry(embedder, config) {
             const result = await embedder.dim();
             globalEmbedderHealth.lastSuccess = Date.now();
             globalEmbedderHealth.lastError = null;
+            globalEmbedderHealth.fallbackActive = false;
             return result;
         }
         catch (error) {

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.4";
+const PLUGIN_VERSION = "1.3.6";
 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)
@@ -160,7 +160,11 @@ const plugin = async (input) => {
                 // (ProviderAuthError/UnknownError/MessageAbortedError/ApiError —
                 // all expose data.message), so we also keep the raw message and
                 // classify it at session end to fill failureType/errorMessage.
-                const sid = evt.properties?.sessionID;
+                // ERROR_SESSION_ID_FALLBACK (1.3.5): session.error carried the
+                // sessionID at properties.sessionID while created/deleted use
+                // properties.info.id — if the SDK ever omits one, don't lose
+                // the failure classification.
+                const sid = evt.properties?.sessionID ?? evt.properties?.info?.id;
                 if (sid) {
                     const err = evt.properties?.error;
                     const message = typeof err?.data?.message === "string"
@@ -183,19 +187,37 @@ const plugin = async (input) => {
             if (evt.type === "session.deleted") {
                 const sid = evt.properties?.info?.id;
                 if (sid && !isOwnSession(sid)) {
+                    // SESSION_DELETED_FLUSH (1.3.5): capture fragments were
+                    // only ever flushed on session.idle, so quick sessions
+                    // lost their transcript AND leaked their captureBuffer
+                    // entry. Flush before the session disappears.
+                    try {
+                        await flushAutoCapture(sid, state, input.client);
+                    }
+                    catch (error) {
+                        log("warn", `failed to flush capture on session end: ${toErrorMessage(error)}`);
+                    }
                     const entry = state.sessionErrors.get(sid);
                     state.sessionErrors.delete(sid);
                     const hadError = entry?.failed === true;
                     await handleSessionEnd(sid, state, hadError ? "failed" : "success", entry?.message);
+                    // Session is closing — final dedup pass for its scope. Uses the
+                    // session's own directory (Session.info.directory) rather than
+                    // client.session.get, which may 404 after deletion. force=true
+                    // bypasses the idle cooldown since this is a one-time cleanup.
+                    const deletedInfo = evt.properties?.info;
+                    const finalScope = deletedInfo?.directory ? deriveProjectScope(deletedInfo.directory) : state.defaultScope;
+                    maybeConsolidateDuplicates(state, finalScope, true);
+                    maybeSweepExpiredMemories(state, finalScope, true);
                 }
-                // Session is closing — final dedup pass for its scope. Uses the
-                // session's own directory (Session.info.directory) rather than
-                // client.session.get, which may 404 after deletion. force=true
-                // bypasses the idle cooldown since this is a one-time cleanup.
-                const deletedInfo = evt.properties?.info;
-                const finalScope = deletedInfo?.directory ? deriveProjectScope(deletedInfo.directory) : state.defaultScope;
-                maybeConsolidateDuplicates(state, finalScope, true);
-                maybeSweepExpiredMemories(state, finalScope, true);
+                // OWN_SESSION_CLEANUP (1.3.5): the consolidate/sweep calls
+                // above used to run UNCONDITIONALLY — including for the
+                // plugin's own ephemeral LLM-capture/digest sessions, with
+                // force=true bypassing the cooldown. In capture.mode="llm"
+                // every LLM round trip paid a full consolidate+retention scan
+                // on teardown and could trigger further LLM digests. Own
+                // sessions are now skipped entirely (handleSessionEnd guard
+                // covers the rest).
                 return;
             }
             const sessionID = evt.properties?.sessionID;
@@ -256,6 +278,18 @@ const plugin = async (input) => {
             if (validation) {
                 try {
                     await state.store.addValidationOutcome(taskId, activeScope, validation);
+                    // RETRY_ATTEMPT_WIRE (1.3.5): failed validations are the
+                    // only real "attempt" signal the plugin sees (same command
+                    // family retried in the sessions). Record them so
+                    // retry_budget_suggest has data instead of always
+                    // answering "1 retry". addRetryAttempt assigns the
+                    // 1-based attemptNumber/timestamp.
+                    if (validation.status === "fail") {
+                        await state.store.addRetryAttempt(taskId, activeScope, {
+                            outcome: "failed",
+                            errorMessage: (validation.output ?? "").slice(0, 500),
+                        });
+                    }
                 }
                 catch (error) {
                     log("warn", `failed to record validation outcome: ${toErrorMessage(error)}`);
@@ -448,6 +482,14 @@ const plugin = async (input) => {
             for (const result of limitedResults) {
                 state.store.updateMemoryUsage(result.record.id, activeScope, scopes).catch(() => { });
             }
+            // EPISODE_RECALL_USED (1.3.5): stamp the session's task episode so
+            // memory_kpi's memory-lift metric can actually separate tasks that
+            // used recall from tasks that didn't (nothing ever set it before).
+            const recallEpisode = state.activeEpisodes.get(eventInput.sessionID);
+            if (recallEpisode) {
+                state.store.markEpisodeRecallUsed(recallEpisode.taskId, recallEpisode.scope)
+                    .catch((error) => log("warn", `failed to mark episode recall used: ${toErrorMessage(error)}`));
+            }
             // Apply summarization if configured
             const summarizationConfig = createSummarizationConfig(state.config.injection);
             const processedResults = limitedResults.map((item) => {
@@ -554,8 +596,10 @@ async function createRuntimeState(input) {
                 if (state.graph?.enabled) {
                     // One-time backfill: index existing memories into the graph
                     // so recall boosts work immediately, not only for new captures.
+                    // GRAPH_BACKFILL_ALL (1.3.5): was readByScopes(["global"]),
+                    // which skipped every project-scoped memory.
                     try {
-                        const records = await state.store.readByScopes(["global"]);
+                        const records = await state.store.readAllActive();
                         state.graph.reindexMemories(records);
                     }
                     catch (error) {
@@ -671,6 +715,14 @@ async function flushAutoCapture(sessionID, state, client) {
             skipReason: candidates === null ? "llm-unavailable" : "llm-empty-result",
             text: combined,
         });
+        // LLM_EMPTY_VERDICT (1.3.5): when the LLM ran fine but deliberately
+        // returned [] ("nothing here is memory-worthy"), that is a real
+        // verdict, not a failure — falling through to the keyword heuristics
+        // stored transcript content the LLM explicitly rejected. Only fall
+        // back when extraction FAILED (candidates === null).
+        if (candidates !== null) {
+            return;
+        }
     }
     const result = extractCaptureCandidate(combined, state.config.minCaptureChars);
     if (!result.candidate) {

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) {
@@ -409,7 +467,10 @@ export class MemoryStore {
         }
         const cutoffTimestamp = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
         const table = this.requireEventTable();
-        const allExpired = await table.query().where(`timestamp < ${cutoffTimestamp}`).toArray();
+        // TTL_STATUS_BOUND (1.3.5): was an unbounded toArray() over every
+        // expired event (this store has seen 636MB event tables). Bound it
+        // like every other read path; the status is an estimate anyway.
+        const allExpired = await table.query().where(`timestamp < ${cutoffTimestamp}`).limit(100000).toArray();
         const expiredCount = allExpired.length;
         const scopeBreakdown = {};
         for (const row of allExpired) {
@@ -429,6 +490,14 @@ export class MemoryStore {
             tags: record.tags ?? undefined,
             status: record.status ?? "active",
             parentId: record.parentId ?? undefined,
+            // CITATION_CHAIN_SERIALIZE (1.3.5): citationChain is a STRING
+            // column (normalizeRow JSON.parses it on read; updateCitation
+            // stringifies it). The import path passed a raw array, which
+            // stored "src" via Array.prototype.toString and broke chains on
+            // round trip. Normalize at the chokepoint so every writer agrees.
+            citationChain: Array.isArray(record.citationChain)
+                ? JSON.stringify(record.citationChain)
+                : record.citationChain,
         };
         await table.add([recordWithDefaults]);
         this.invalidateScope(record.scope);
@@ -545,6 +614,20 @@ export class MemoryStore {
         this.notifyGraphRemoved(match.id);
         return true;
     }
+    // DELETE_BY_RAW_ID (1.3.5): exact-id hard delete that sees rows the
+    // filtered reads hide (digested/merged/disabled). Used by memory_import
+    // replace-mode so a pre-existing hidden row is actually replaced instead
+    // of leaving two physical rows with the same id.
+    async deleteByIdRaw(id) {
+        const table = this.requireTable();
+        const rows = await table.query().where(`id = '${escapeSql(id)}'`).limit(1).toArray();
+        if (rows.length === 0)
+            return false;
+        await table.delete(`id = '${escapeSql(id)}'`);
+        this.invalidateScope(rows[0].scope);
+        this.notifyGraphRemoved(id);
+        return true;
+    }
     async softDeleteMemory(id, scopes) {
         const rows = await this.readByScopes(scopes);
         const match = rows.find((row) => this.matchesId(row.id, id));
@@ -633,7 +716,15 @@ export class MemoryStore {
         return toDelete.length;
     }
     async consolidateDuplicates(scope, threshold, candidateLimit = 50) {
-        const rows = await this.readByScopesIncludingMerged([scope]);
+        // MERGE_STATUS_FILTER (1.3.5): consolidation used to run over
+        // readByScopesIncludingMerged and only consulted METADATA
+        // status:merged/mergedFrom — so digested (retention-hidden) and
+        // disabled (soft-deleted) rows could be picked as merge endpoints and
+        // have their column status overwritten to "merged", resurrecting
+        // disabled rows and corrupting digest provenance. Only active/unset
+        // rows may participate.
+        let rows = await this.readByScopesIncludingMerged([scope]);
+        rows = rows.filter((r) => r.status === undefined || r.status === null || r.status === "" || r.status === "active");
         if (rows.length === 0) {
             return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0 };
         }
@@ -999,14 +1090,23 @@ export class MemoryStore {
             const projects = extractRecalledProjects(metadataJson);
             if (!projects.has(projectScope)) {
                 projects.add(projectScope);
+                // METADATA_MERGE_FIX (1.3.5): this previously REPLACED
+                // metadataJson with `{ recalledProjects: [...] }`, silently
+                // dropping source / isPotentialDuplicate / graphEntities /
+                // pinned on the first recall of every global memory. In the
+                // default scoping:"global" mode that hit every memory, which
+                // broke pruneScope (duplicate-flag based) and retention
+                // (pinned protections). Merge into the existing blob instead.
+                const baseMeta = parseMetadata(metadataJson);
                 if (projects.size > 100) {
                     const arr = Array.from(projects);
                     arr.splice(0, arr.length - 100);
-                    metadataJson = JSON.stringify({ recalledProjects: arr });
+                    baseMeta.recalledProjects = arr;
                 }
                 else {
-                    metadataJson = JSON.stringify({ recalledProjects: Array.from(projects) });
+                    baseMeta.recalledProjects = Array.from(projects);
                 }
+                metadataJson = JSON.stringify(baseMeta);
                 newProjectCount = projects.size;
             }
         }
@@ -1532,6 +1632,11 @@ export class MemoryStore {
                 const records = await this.readByScopes([scope]);
                 let sortedRecords = records;
                 if (records.length > this.cacheConfig.maxRecordsPerScope) {
+                    // SCOPE_CACHE_TRUNCATE (1.3.5): truncation used to be
+                    // silent, which made older memories permanently invisible
+                    // to search. Log it once per cache rebuild so the operator
+                    // knows to raise cacheConfig.maxRecordsPerScope.
+                    log("warn", `[store] scope cache truncated: ${scope} has ${records.length} records but maxRecordsPerScope=${this.cacheConfig.maxRecordsPerScope}; older memories are not searchable until the limit is raised`);
                     sortedRecords = [...records].sort((a, b) => b.timestamp - a.timestamp).slice(0, this.cacheConfig.maxRecordsPerScope);
                 }
                 const tokenized = sortedRecords.map((record) => tokenize(record.text));
@@ -1812,7 +1917,54 @@ export class MemoryStore {
         return patterns.sort((a, b) => b.count - a.count);
     }
     async addRetryAttempt(taskId, scope, attempt) {
-        return this.appendToEpisodeField(taskId, scope, "retryAttemptsJson", (raw) => JSON.parse(raw || "[]"), (items) => JSON.stringify(items), attempt, (item) => ({ ...item, timestamp: Date.now() }));
+        // RETRY_ATTEMPT_COUNT (1.3.5): was a blind push via
+        // appendToEpisodeField — attemptNumber was never provided by any
+        // caller, so retry_budget_suggest always saw attempts.length === 0.
+        // Compute the 1-based attempt number from the existing array so the
+        // retry-budget median is over real values. Also the only live writer
+        // (tool.execute.after validation failures) now wired in index.js.
+        await this.ensureEpisodicTaskTable(384);
+        const table = this.requireEpisodicTaskTable();
+        const rows = await table.query().where(`taskId = '${escapeSql(taskId)}' AND scope = '${escapeSql(scope)}'`).toArray();
+        if (rows.length === 0)
+            return false;
+        const existing = rows[0];
+        const items = JSON.parse(existing.retryAttemptsJson || "[]");
+        items.push({
+            ...attempt,
+            attemptNumber: items.length + 1,
+            timestamp: Date.now(),
+        });
+        await table.update({
+            where: `id = '${escapeSql(existing.id)}'`,
+            values: { retryAttemptsJson: JSON.stringify(items) },
+        });
+        return true;
+    }
+    // EPISODE_RECALL_USED (1.3.5): stamps metadata.recallUsed on the session's
+    // task episode so calculateMemoryLift can separate tasks that used recall
+    // from tasks that didn't (the field existed but nothing ever set it, so
+    // memory_kpi always reported "no-recall-data").
+    async markEpisodeRecallUsed(taskId, scope) {
+        await this.ensureEpisodicTaskTable(384);
+        const table = this.requireEpisodicTaskTable();
+        const rows = await table.query().where(`taskId = '${escapeSql(taskId)}' AND scope = '${escapeSql(scope)}'`).toArray();
+        if (rows.length === 0)
+            return false;
+        const existing = rows[0];
+        let metadata = {};
+        try {
+            metadata = JSON.parse(existing.metadataJson || "{}");
+        }
+        catch {
+            metadata = {};
+        }
+        metadata.recallUsed = true;
+        await table.update({
+            where: `id = '${escapeSql(existing.id)}'`,
+            values: { metadataJson: JSON.stringify(metadata) },
+        });
+        return true;
     }
     async addRecoveryStrategy(taskId, scope, strategy) {
         return this.appendToEpisodeField(taskId, scope, "recoveryStrategiesJson", (raw) => JSON.parse(raw || "[]"), (items) => JSON.stringify(items), strategy, (item) => ({ ...item, attemptedAt: Date.now() }));
@@ -2304,6 +2456,48 @@ export class MemoryStore {
             .map((row) => normalizeRow(row))
             .filter((row) => row !== null);
     }
+    // GRAPH_BACKFILL_ALL (1.3.5): the one-time graph backfill previously
+    // read only ["global"], so project-scoped memories (scoping:"project")
+    // never entered the entity graph. Reads every active row across ALL
+    // scopes with the same status filter as readByScopes.
+    async readAllActive() {
+        const table = this.requireTable();
+        const rows = await table
+            .query()
+            .where(`(status != 'disabled' OR status IS NULL OR status = '') AND NOT (status = 'merged') AND NOT (status = 'digested') AND NOT (metadataJson LIKE '%"status":"merged"%')`)
+            .select([
+            "id",
+            "text",
+            "vector",
+            "category",
+            "scope",
+            "importance",
+            "timestamp",
+            "lastRecalled",
+            "recallCount",
+            "projectCount",
+            "schemaVersion",
+            "embeddingModel",
+            "vectorDim",
+            "metadataJson",
+            "userId",
+            "teamId",
+            "sourceSessionId",
+            "confidence",
+            "tags",
+            "status",
+            "parentId",
+            "citationSource",
+            "citationTimestamp",
+            "citationStatus",
+            "citationChain",
+        ])
+            .limit(100000)
+            .toArray();
+        return rows
+            .map((row) => normalizeRow(row))
+            .filter((row) => row !== null);
+    }
     async ensureIndexes() {
         const table = this.requireTable();
         // INDEX_USAGE_FIX (1.1.7): the FTS "text" index was created here but

package/dist/tools/memory.js

@@ -453,12 +453,17 @@ export function createMemoryTools(state) {
                     await state.store.putEvent({
                         id: generateId(),
                         type: "feedback",
-                        feedbackType: "useful",
+                        // FORGET_FEEDBACK (1.3.5): was feedbackType "useful" with
+                        // helpful:false, polluting the unhelpful-recall stats.
+                        // "wrong" is the semantically-correct signal (memory
+                        // should not be stored) and feeds the false-positive
+                        // rate / wrong penalty.
+                        feedbackType: "wrong",
                         scope: activeScope,
                         sessionID: context.sessionID,
                         timestamp: Date.now(),
                         memoryId: args.id,
-                        helpful: false,
+                        reason: "explicit-forget (hard delete)",
                         metadataJson: JSON.stringify({ source: "explicit-forget", hardDelete: true }),
                     });
                     return `Permanently deleted memory ${args.id}.`;
@@ -470,12 +475,14 @@ export function createMemoryTools(state) {
                 await state.store.putEvent({
                     id: generateId(),
                     type: "feedback",
-                    feedbackType: "useful",
+                    // FORGET_FEEDBACK (1.3.5): was feedbackType "useful" with
+                    // helpful:false, polluting the unhelpful-recall stats.
+                    feedbackType: "wrong",
                     scope: activeScope,
                     sessionID: context.sessionID,
                     timestamp: Date.now(),
                     memoryId: args.id,
-                    helpful: false,
+                    reason: "explicit-forget (soft delete)",
                     metadataJson: JSON.stringify({ source: "explicit-forget", hardDelete: false }),
                 });
                 return `Soft-deleted (disabled) memory ${args.id}. Use force=true for permanent deletion.`;
@@ -1081,7 +1088,14 @@ ${explanations.join("\n")}`;
                         continue;
                     }
                     try {
-                        const exists = await state.store.hasMemory(m.id, scopes);
+                        // IMPORT_EXISTS_RAW (1.3.5): hasMemory only sees ACTIVE
+                        // rows, so replace-mode imported a second active row
+                        // with the same id when a digested/merged/disabled row
+                        // already existed (Lance has no primary key → two
+                        // physical rows per id → ambiguous lookups). Check the
+                        // raw id and delete the raw row on replace.
+                        const existingRows = await state.store.findRawRecordsByIds([m.id], scopes);
+                        const exists = existingRows.length > 0;
                         if (exists && args.mode !== "replace") {
                             skipped += 1;
                             continue;
@@ -1096,7 +1110,7 @@ ${explanations.join("\n")}`;
                             continue;
                         }
                         if (exists) {
-                            await state.store.deleteById(m.id, scopes);
+                            await state.store.deleteByIdRaw(m.id);
                         }
                         let vector = Array.isArray(m.vector) ? m.vector.map(Number) : [];
                         if (vector.length !== embedderDim) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memory-pro",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "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",