lancedb-opencode-pro 0.1.4 → 0.1.6

package/README.md

@@ -272,7 +272,7 @@ Example output:
 ```json
 {
   "scope": "project:my-project",
-  "totalEvents": 12,
+  "totalEvents": 14,
   "capture": {
     "considered": 4,
     "stored": 3,
@@ -283,11 +283,24 @@ Example output:
     }
   },
   "recall": {
-    "requested": 3,
+    "requested": 4,
     "injected": 2,
-    "returnedResults": 2,
-    "hitRate": 0.67,
-    "injectionRate": 0.67
+    "returnedResults": 3,
+    "hitRate": 0.75,
+    "injectionRate": 0.5,
+    "auto": {
+      "requested": 3,
+      "injected": 2,
+      "returnedResults": 2,
+      "hitRate": 0.67,
+      "injectionRate": 0.67
+    },
+    "manual": {
+      "requested": 1,
+      "returnedResults": 1,
+      "hitRate": 1
+    },
+    "manualRescueRatio": 0.33
   },
   "feedback": {
     "missing": 1,
@@ -306,7 +319,10 @@ Example output:
 Key fields:
 
 - `capture.successRate`: how often a considered candidate was stored.
-- `recall.hitRate`: how often a recall request returned at least one result.
+- `recall.hitRate`: blended rate across auto and manual recall — how often any recall request returned at least one result.
+- `recall.auto.*`: metrics for automatic recall injected into the system prompt during `experimental.chat.system.transform`.
+- `recall.manual.*`: metrics for user-initiated `memory_search` calls; `injected` is always false for manual searches.
+- `recall.manualRescueRatio`: `manual.requested / auto.requested` — a proxy for how often users still need to search manually despite automatic recall.
 - `feedback.falsePositiveRate`: wrong-memory reports divided by stored memories.
 - `feedback.falseNegativeRate`: missing-memory reports relative to capture attempts.
 
@@ -315,6 +331,8 @@ Key fields:
 In real OpenCode usage, auto-capture and recall happen in the background, so explicit `memory_feedback_*` events are often sparse.
 
 - Treat `capture.*` and `recall.*` as system-health metrics: they show whether the memory pipeline is running.
+- Treat `recall.auto.*` and `recall.manual.*` separately: auto metrics reflect pipeline health; manual metrics reflect whether users still need to rescue context manually.
+- Treat `recall.manualRescueRatio` as a proxy for manual rescue rate: a high ratio suggests automatic recall is not surfacing relevant context on its own.
 - Treat repeated-context reduction, clarification burden, manual memory rescue, correction signals, and sampled audits as product-value signals: they show whether memory actually helped the user.
 - Treat `feedback.* = 0` as insufficient evidence, not proof that memory quality is good.
 - Treat a high `recall.hitRate` or `recall.injectionRate` as recall availability only; those values do not prove usefulness by themselves.

package/dist/index.js

@@ -64,6 +64,7 @@ const plugin = async (input) => {
             await state.store.putEvent({
                 id: generateId(),
                 type: "recall",
+                source: "system-transform",
                 scope: activeScope,
                 sessionID: eventInput.sessionID,
                 timestamp: Date.now(),
@@ -117,6 +118,17 @@ const plugin = async (input) => {
                         recencyHalfLifeHours: state.config.retrieval.recencyHalfLifeHours,
                         importanceWeight: state.config.retrieval.importanceWeight,
                     });
+                    await state.store.putEvent({
+                        id: generateId(),
+                        type: "recall",
+                        source: "manual-search",
+                        scope: activeScope,
+                        sessionID: context.sessionID,
+                        timestamp: Date.now(),
+                        resultCount: results.length,
+                        injected: false,
+                        metadataJson: JSON.stringify({ source: "manual-search" }),
+                    });
                     if (results.length === 0)
                         return "No relevant memory found.";
                     return results

package/dist/store.d.ts

@@ -44,4 +44,5 @@ export declare class MemoryStore {
     private readEventsByScopes;
     private readByScopes;
     private ensureIndexes;
+    private ensureEventTableCompatibility;
 }

package/dist/store.js

@@ -3,6 +3,7 @@ import { dirname } from "node:path";
 import { tokenize } from "./utils.js";
 const TABLE_NAME = "memories";
 const EVENTS_TABLE_NAME = "effectiveness_events";
+const EVENTS_SOURCE_COLUMN = "source";
 export class MemoryStore {
     dbPath;
     lancedb = null;
@@ -59,6 +60,7 @@ export class MemoryStore {
                 skipReason: "",
                 resultCount: 0,
                 injected: false,
+                source: "",
                 feedbackType: "",
                 helpful: -1,
                 reason: "",
@@ -68,6 +70,7 @@ export class MemoryStore {
             this.eventTable = await this.connection.createTable(EVENTS_TABLE_NAME, [bootstrapEvent]);
             await this.eventTable.delete("id = '__bootstrap__'");
         }
+        await this.ensureEventTableCompatibility();
         await this.ensureIndexes();
     }
     async put(record) {
@@ -89,6 +92,7 @@ export class MemoryStore {
                 skipReason: event.type === "capture" ? event.skipReason ?? "" : "",
                 resultCount: event.type === "recall" ? event.resultCount : 0,
                 injected: event.type === "recall" ? event.injected : false,
+                source: event.type === "recall" ? event.source ?? "" : "",
                 feedbackType: event.type === "feedback" ? event.feedbackType : "",
                 helpful: event.type === "feedback" ? (event.helpful === undefined ? -1 : event.helpful ? 1 : 0) : -1,
                 reason: event.type === "feedback" ? event.reason ?? "" : "",
@@ -207,6 +211,11 @@ export class MemoryStore {
         let recallRequested = 0;
         let recallInjected = 0;
         let recallReturnedResults = 0;
+        let autoRecallRequested = 0;
+        let autoRecallInjected = 0;
+        let autoRecallReturnedResults = 0;
+        let manualRecallRequested = 0;
+        let manualRecallReturnedResults = 0;
         let feedbackMissing = 0;
         let feedbackWrong = 0;
         let feedbackUsefulPositive = 0;
@@ -230,6 +239,19 @@ export class MemoryStore {
                     recallReturnedResults += 1;
                 if (event.injected)
                     recallInjected += 1;
+                const recallSource = event.source ?? "system-transform";
+                if (recallSource === "manual-search") {
+                    manualRecallRequested += 1;
+                    if (event.resultCount > 0)
+                        manualRecallReturnedResults += 1;
+                }
+                else {
+                    autoRecallRequested += 1;
+                    if (event.resultCount > 0)
+                        autoRecallReturnedResults += 1;
+                    if (event.injected)
+                        autoRecallInjected += 1;
+                }
             }
             if (event.type === "feedback") {
                 if (event.feedbackType === "missing")
@@ -262,6 +284,19 @@ export class MemoryStore {
                 returnedResults: recallReturnedResults,
                 hitRate: recallRequested === 0 ? 0 : recallReturnedResults / recallRequested,
                 injectionRate: recallRequested === 0 ? 0 : recallInjected / recallRequested,
+                auto: {
+                    requested: autoRecallRequested,
+                    injected: autoRecallInjected,
+                    returnedResults: autoRecallReturnedResults,
+                    hitRate: autoRecallRequested === 0 ? 0 : autoRecallReturnedResults / autoRecallRequested,
+                    injectionRate: autoRecallRequested === 0 ? 0 : autoRecallInjected / autoRecallRequested,
+                },
+                manual: {
+                    requested: manualRecallRequested,
+                    returnedResults: manualRecallReturnedResults,
+                    hitRate: manualRecallRequested === 0 ? 0 : manualRecallReturnedResults / manualRecallRequested,
+                },
+                manualRescueRatio: autoRecallRequested === 0 ? 0 : manualRecallRequested / autoRecallRequested,
             },
             feedback: {
                 missing: feedbackMissing,
@@ -346,6 +381,7 @@ export class MemoryStore {
             "skipReason",
             "resultCount",
             "injected",
+            "source",
             "feedbackType",
             "helpful",
             "reason",
@@ -411,6 +447,21 @@ export class MemoryStore {
             this.indexState.ftsError = error instanceof Error ? error.message : String(error);
         }
     }
+    async ensureEventTableCompatibility() {
+        const table = this.requireEventTable();
+        const schema = await table.schema();
+        const hasSourceColumn = schema.fields.some((field) => field.name === EVENTS_SOURCE_COLUMN);
+        if (hasSourceColumn) {
+            return;
+        }
+        try {
+            await table.addColumns([{ name: EVENTS_SOURCE_COLUMN, valueSql: "CAST(NULL AS STRING)" }]);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to patch ${EVENTS_TABLE_NAME} schema for ${EVENTS_SOURCE_COLUMN}: ${reason}`);
+        }
+    }
 }
 function normalizeRow(row) {
     const vectorRaw = row.vector;
@@ -456,11 +507,14 @@ function normalizeEventRow(row) {
         };
     }
     if (row.type === "recall") {
+        const sourceRaw = typeof row.source === "string" && row.source.length > 0 ? row.source : "system-transform";
+        const source = sourceRaw === "manual-search" ? "manual-search" : "system-transform";
         return {
             ...base,
             type: "recall",
             resultCount: Number(row.resultCount ?? 0),
             injected: Boolean(row.injected),
+            source,
         };
     }
     if (row.type === "feedback") {

package/dist/types.d.ts

@@ -4,6 +4,7 @@ export type MemoryCategory = "preference" | "fact" | "decision" | "entity" | "ot
 export type CaptureOutcome = "considered" | "skipped" | "stored";
 export type CaptureSkipReason = "empty-buffer" | "below-min-chars" | "no-positive-signal" | "initialization-unavailable" | "embedding-unavailable" | "empty-embedding";
 export type FeedbackType = "missing" | "wrong" | "useful";
+export type RecallSource = "system-transform" | "manual-search";
 export interface EmbeddingConfig {
     provider: EmbeddingProvider;
     model: string;
@@ -76,6 +77,7 @@ export interface RecallEvent extends MemoryEffectivenessEventBase {
     type: "recall";
     resultCount: number;
     injected: boolean;
+    source?: RecallSource;
 }
 export interface FeedbackEvent extends MemoryEffectivenessEventBase {
     type: "feedback";
@@ -101,6 +103,19 @@ export interface EffectivenessSummary {
         returnedResults: number;
         hitRate: number;
         injectionRate: number;
+        auto: {
+            requested: number;
+            injected: number;
+            returnedResults: number;
+            hitRate: number;
+            injectionRate: number;
+        };
+        manual: {
+            requested: number;
+            returnedResults: number;
+            hitRate: number;
+        };
+        manualRescueRatio: number;
     };
     feedback: {
         missing: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lancedb-opencode-pro",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",
@@ -63,5 +63,10 @@
   "devDependencies": {
     "@types/node": "^22.13.9",
     "typescript": "^5.8.2"
-  }
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
+  "author": ""
 }