opencode-memory-pro 1.3.3 → 1.3.5

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.3";
+const PLUGIN_VERSION = "1.3.5";
 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

@@ -1,4 +1,4 @@
-import { mkdir, readdir } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { validateEpisodicRecord, validateEpisodicRecordArray } from "./types.js";
 import { tokenize } from "./utils.js";
@@ -68,19 +68,89 @@ export class MemoryStore {
     // logged but never fatal.
     static OPTIMIZE_INTERVAL_MS = 6 * 60 * 60 * 1000;
     static OPTIMIZE_MIN_VERSIONS = 500;
+    // OPTIMIZE_LOCK (1.3.4): two opencode processes sharing one store both run
+    // maybeOptimizeAll on first writes after a restart (lastOptimizeAt=0), so
+    // their optimize() calls race. The loser's native Rust env_logger prints
+    // "Compaction commit failed; leaving N rewritten fragment(s) in place for
+    // GC" DIRECTLY to stderr — the plugin has no JS hook to intercept it (no
+    // RUST_LOG in the binary), so it lands on the TUI no matter what log()
+    // does. A lock file serializes compaction across processes; the loser just
+    // 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;
     optimizing = false;
     lastOptimizeAt = 0;
     constructor(dbPath, cacheConfig) {
         this.dbPath = dbPath;
         this.cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
     }
+    /**
+     * Cross-process compaction lock. Returns true when this process owns the
+     * lock; false when another live process holds it (or the lock could not be
+     * taken). Stale locks are reclaimed: owner pid no longer alive, or the lock
+     * file is older than OPTIMIZE_LOCK_TTL_MS (crash fallback; the pid check
+     * covers the normal case).
+     */
+    async acquireOptimizeLock() {
+        await mkdir(this.dbPath, { recursive: true }).catch(() => { });
+        const lockFile = join(this.dbPath, ".optimize.lock");
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                const handle = await open(lockFile, "wx");
+                try {
+                    await handle.writeFile(`${process.pid}\n${Date.now()}\n`, "utf8");
+                }
+                catch { }
+                await handle.close();
+                return true;
+            }
+            catch (error) {
+                if (error?.code !== "EEXIST")
+                    return false;
+                let stale = false;
+                try {
+                    const content = await readFile(lockFile, "utf8");
+                    const [pidStr, tsStr] = content.split("\n");
+                    const ownerPid = Number(pidStr);
+                    const ownerTs = Number(tsStr);
+                    if (!Number.isInteger(ownerPid) || ownerPid <= 0) {
+                        stale = true;
+                    }
+                    else if (Number.isFinite(ownerTs) && Date.now() - ownerTs > MemoryStore.OPTIMIZE_LOCK_TTL_MS) {
+                        stale = true;
+                    }
+                    else if (ownerPid !== process.pid) {
+                        try {
+                            process.kill(ownerPid, 0);
+                        }
+                        catch {
+                            stale = true;
+                        }
+                    }
+                }
+                catch {
+                    stale = true;
+                }
+                if (!stale)
+                    return false;
+                await rm(lockFile, { force: true }).catch(() => { });
+            }
+        }
+        return false;
+    }
+    async releaseOptimizeLock() {
+        await rm(join(this.dbPath, ".optimize.lock"), { force: true }).catch(() => { });
+    }
     /**
      * Version-count-gated Lance compaction. Non-blocking: reads the _versions
      * directory for each open table and optimizes the ones that crossed the
      * threshold (or all when force=true), throttled by an interval so chatty
      * sessions can't trigger it every turn. cleanupOlderThan=1h keeps
      * in-flight recent versions; deleteUnverified removes orphaned fragment
-     * files (safe under Lance's exclusive table write lock).
+     * files (safe under Lance's exclusive table write lock). The cross-process
+     * lock keeps two opencode instances from racing optimize() on a shared
+     * store — the race is what makes lance print "Compaction commit failed" to
+     * stderr (uninterceptable), so the lock is what keeps it out of the TUI.
      */
     async maybeOptimizeAll(force = false) {
         if (this.optimizing)
@@ -121,28 +191,38 @@ export class MemoryStore {
             return;
         this.optimizing = true;
         try {
-            const olderThan = new Date(Date.now() - 60 * 60 * 1000);
-            log("debug", `[store] optimize candidates: ${candidates.map((c) => `${c.table.name}(${c.count})`).join(", ")}`);
-            for (const { table, count } of candidates) {
-                try {
-                    const stats = await table.optimize({ cleanupOlderThan: olderThan, deleteUnverified: true });
-                    log("info", `[store] optimized ${table.name}: ${count} versions before, pruned=${stats.prune.oldVersionsRemoved}, bytesRemoved=${stats.prune.bytesRemoved}`);
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    // Known-benign LanceDB compaction races: a concurrent write
-                    // (or a second optimize pass) commits a newer version between
-                    // our read and our commit. Lance leaves the rewritten
-                    // fragments for GC and the next optimize retry succeeds (and
-                    // the success line below is logged). Keep these out of the
-                    // TUI; they still land in the plugin log file for debugging.
-                    if (/Retryable commit conflict|Compaction commit failed/.test(message)) {
-                        logFileOnly("warn", `[store] optimize conflict for ${table.name} (self-heals on retry): ${message}`);
-                        continue;
+            const lockHeld = await this.acquireOptimizeLock();
+            if (!lockHeld) {
+                logFileOnly("warn", "[store] optimize skipped: another process holds the compaction lock (retries next interval)");
+                return;
+            }
+            try {
+                const olderThan = new Date(Date.now() - 60 * 60 * 1000);
+                log("debug", `[store] optimize candidates: ${candidates.map((c) => `${c.table.name}(${c.count})`).join(", ")}`);
+                for (const { table, count } of candidates) {
+                    try {
+                        const stats = await table.optimize({ cleanupOlderThan: olderThan, deleteUnverified: true });
+                        log("info", `[store] optimized ${table.name}: ${count} versions before, pruned=${stats.prune.oldVersionsRemoved}, bytesRemoved=${stats.prune.bytesRemoved}`);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        // Known-benign LanceDB compaction races: a concurrent write
+                        // (or a second optimize pass) commits a newer version between
+                        // our read and our commit. Lance leaves the rewritten
+                        // fragments for GC and the next optimize retry succeeds (and
+                        // the success line below is logged). Keep these out of the
+                        // TUI; they still land in the plugin log file for debugging.
+                        if (/Retryable commit conflict|Compaction commit failed/.test(message)) {
+                            logFileOnly("warn", `[store] optimize conflict for ${table.name} (self-heals on retry): ${message}`);
+                            continue;
+                        }
+                        log("warn", `[store] optimize failed for ${table.name}: ${message}`);
                     }
-                    log("warn", `[store] optimize failed for ${table.name}: ${message}`);
                 }
             }
+            finally {
+                await this.releaseOptimizeLock();
+            }
         }
         finally {
             this.optimizing = false;
@@ -224,9 +304,13 @@ export class MemoryStore {
         // LANCE_COMPACTION_FIX (1.1.6): fire-and-forget so a first-run
         // compaction of a backlogged store (13k+ versions) doesn't block init —
         // it compacts in the background once the version gate passes.
-        void this.maybeOptimizeAll(false).catch((error) => {
-            log("warn", `[store] startup optimize failed: ${error instanceof Error ? error.message : String(error)}`);
-        });
+        // OPTIMIZE_JITTER (1.3.4): staggered 5–30s so two instances that boot
+        // together don't race for the compaction lock in the same instant.
+        setTimeout(() => {
+            void this.maybeOptimizeAll(false).catch((error) => {
+                log("warn", `[store] startup optimize failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 5_000 + Math.floor(Math.random() * 25_000));
     }
     // GRACEFUL_SHUTDOWN: lance's commit path spawns a background
     // auto_cleanup_hook task; if the process exits without closing the
@@ -325,7 +409,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) {
@@ -345,6 +432,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);
@@ -461,6 +556,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));
@@ -549,7 +658,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 };
         }
@@ -915,14 +1032,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;
             }
         }
@@ -1448,6 +1574,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));
@@ -1728,7 +1859,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() }));
@@ -2220,6 +2398,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.3",
+  "version": "1.3.5",
   "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",