lancedb-opencode-pro 0.2.4 → 0.2.5

package/README.md

@@ -383,14 +383,14 @@ Add an `injection` block to your sidecar config:
     "mode": "fixed",
     "maxMemories": 3,
     "minMemories": 1,
-    "budgetTokens": 2000,
+    "budgetTokens": 4096,
     "maxCharsPerMemory": 1200,
     "summarization": "none",
-    "summaryTargetChars": 400,
+    "summaryTargetChars": 300,
     "scoreDropTolerance": 0.15,
-    "injectionFloor": 0.3,
+    "injectionFloor": 0.2,
     "codeSummarization": {
-      "mode": "truncate",
+      "mode": "smart",
       "preserveStructure": true
     }
   }
@@ -416,7 +416,7 @@ When `summarization` is set to `truncate` or `extract`, memories are summarized
 
 The `codeSummarization` config controls how code snippets are processed:
 
-- **`mode`**: `"truncate"` | `"preserve"` | `"auto"` (default: `"truncate"`)
+- **`mode`**: `"smart"` | `"truncate"` | `"preserve"` (default: `"smart"`)
 - **`preserveStructure`**: When `true`, code truncation attempts to balance brackets and preserve syntactic validity.
 
 ### Environment Variables
@@ -474,9 +474,9 @@ For quality-sensitive scenarios where you want to avoid low-relevance memories:
   "injection": {
     "mode": "adaptive",
     "maxMemories": 5,
-    "minMemories": 1,
+    "minMemories": 2,
     "scoreDropTolerance": 0.15,
-    "injectionFloor": 0.3
+    "injectionFloor": 0.2
   }
 }
 ```
@@ -485,7 +485,38 @@ This configuration:
 1. Starts with up to 5 candidate memories
 2. Stops adding memories when score drops >15% from the top
 3. Ensures minimum score threshold (floor) prevents low-quality injection
-4. Always includes at least 1 memory
+4. Always includes at least 2 memories
+
+### Example: Adaptive Mode with Auto Summarization
+
+Recommended for users who want intelligent memory injection with content-aware summarization:
+
+```json
+{
+  "injection": {
+    "mode": "adaptive",
+    "maxMemories": 5,
+    "minMemories": 2,
+    "budgetTokens": 4096,
+    "maxCharsPerMemory": 1200,
+    "summarization": "auto",
+    "summaryTargetChars": 400,
+    "scoreDropTolerance": 0.15,
+    "injectionFloor": 0.2,
+    "codeSummarization": {
+      "mode": "smart",
+      "preserveStructure": true
+    }
+  }
+}
+```
+
+This configuration:
+1. Dynamically adjusts injection count based on relevance scores
+2. Uses content-aware summarization (key sentences for text, smart truncation for code)
+3. Guarantees at least 2 memories are injected
+4. Preserves code structure when truncating
+5. Prevents injection of memories below 0.2 score threshold
 
 ---
 
@@ -632,7 +663,7 @@ The project provides layered validation workflows that can run locally or inside
 | `npm run verify` | Typecheck + build + effectiveness workflow + retrieval (quick release check) |
 | `npm run verify:full` | All of the above + benchmark + `npm pack` (full release gate) |
 
-Threshold policy and benchmark profiles are documented in `docs/benchmark-thresholds.md`.
+Threshold policy and benchmark profiles are documented in `docs/memory-validation-checklist.md` (Phase 4.4).
 Acceptance evidence mapping and archive/ship gate policy are documented in `docs/release-readiness.md`.
 
 ## Maintainer Release SOP
@@ -644,7 +675,7 @@ Use this flow when publishing a new version to npm.
 
 ```bash
 docker compose build --no-cache && docker compose up -d
-docker compose exec app npm run release:check
+docker compose exec opencode-dev npm run release:check
 ```
 
 3. Confirm npm authentication:
@@ -700,8 +731,8 @@ ls -l dist dist-test/src 2>/dev/null
 
 ```bash
 docker compose build --no-cache && docker compose up -d
-docker compose exec app npm run typecheck
-docker compose exec app npm run build
+docker compose exec opencode-dev npm run typecheck
+docker compose exec opencode-dev npm run build
 ```
 
 ### Running validation inside Docker
@@ -710,16 +741,16 @@ docker compose exec app npm run build
 docker compose build --no-cache && docker compose up -d
 
 # Quick release check
-docker compose exec app npm run verify
+docker compose exec opencode-dev npm run verify
 
 # Full release gate (includes benchmark + pack)
-docker compose exec app npm run verify:full
+docker compose exec opencode-dev npm run verify:full
 
 # Individual workflows
-docker compose exec app npm run test:foundation
-docker compose exec app npm run test:regression
-docker compose exec app npm run test:retrieval
-docker compose exec app npm run benchmark:latency
+docker compose exec opencode-dev npm run test:foundation
+docker compose exec opencode-dev npm run test:regression
+docker compose exec opencode-dev npm run test:retrieval
+docker compose exec opencode-dev npm run benchmark:latency
 ```
 
 ### Operator verification
@@ -728,15 +759,15 @@ After running `npm run verify:full`, operators can inspect the following:
 
 ```bash
 # Confirm the packaged build is installable
-docker compose exec app ls -la lancedb-opencode-pro-*.tgz
+docker compose exec opencode-dev ls -la lancedb-opencode-pro-*.tgz
 
 # Confirm typecheck and build succeeded
-docker compose exec app npm run typecheck
-docker compose exec app npm run build
+docker compose exec opencode-dev npm run typecheck
+docker compose exec opencode-dev npm run build
 
 # Check resolved default storage path
-docker compose exec app node -e "import('./dist/index.js').then(() => console.log('plugin loaded'))"
-docker compose exec app sh -lc 'ls -la ~/.opencode/memory/lancedb 2>/dev/null || echo "No data yet (expected before first use)"'
+docker compose exec opencode-dev node -e "import('./dist/index.js').then(() => console.log('plugin loaded'))"
+docker compose exec opencode-dev sh -lc 'ls -la ~/.opencode/memory/lancedb 2>/dev/null || echo "No data yet (expected before first use)"'
 ```
 
 ## Long Memory Verification
@@ -754,14 +785,14 @@ docker compose build --no-cache && docker compose up -d
 The E2E script loads `dist/index.js`, so build artifacts must exist first.
 
 ```bash
-docker compose exec app npm install
-docker compose exec app npm run build
+docker compose exec opencode-dev npm install
+docker compose exec opencode-dev npm run build
 ```
 
 ### 3. Run the built-in end-to-end memory test
 
 ```bash
-docker compose exec app npm run test:e2e
+docker compose exec opencode-dev npm run test:e2e
 ```
 
 Expected success output:
@@ -783,7 +814,7 @@ This verifies all of the following in one run:
 The E2E script uses `/tmp/opencode-memory-e2e` as its test database path.
 
 ```bash
-docker compose exec app ls -la /tmp/opencode-memory-e2e
+docker compose exec opencode-dev ls -la /tmp/opencode-memory-e2e
 ```
 
 If files appear in that directory after the E2E run, memory was written to disk instead of only being kept in process memory.
@@ -799,7 +830,7 @@ When running through the normal plugin config, the default durable storage path
 Check it inside the container with:
 
 ```bash
-docker compose exec app sh -lc 'ls -la ~/.opencode/memory/lancedb'
+docker compose exec opencode-dev sh -lc 'ls -la ~/.opencode/memory/lancedb'
 ```
 
 ### 6. Stronger proof: verify retrieval still works after restart
@@ -808,8 +839,8 @@ Long memory is only convincing if retrieval still works after the runtime is res
 
 ```bash
 docker compose restart app
-docker compose exec app npm run test:e2e
-docker compose exec app ls -la /tmp/opencode-memory-e2e
+docker compose exec opencode-dev npm run test:e2e
+docker compose exec opencode-dev ls -la /tmp/opencode-memory-e2e
 ```
 
 If the search step still succeeds after restart and the database files remain present, that is strong evidence that the memory is durable.
@@ -818,7 +849,7 @@ If the search step still succeeds after restart and the database files remain pr
 
 Treat the feature as verified only when all of these are true:
 
-- `docker compose exec app npm run test:e2e` passes
+- `docker compose exec opencode-dev npm run test:e2e` passes
 - `/tmp/opencode-memory-e2e` contains LanceDB files after the run
 - the memory retrieval step still succeeds after container restart
 - the configured OpenCode storage path exists when running real plugin integration

package/dist/config.js

@@ -39,6 +39,7 @@ export function resolveMemoryConfig(config, worktree) {
         : process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS;
     const timeoutRaw = timeoutEnv ?? embeddingRaw.timeoutMs;
     const injection = resolveInjectionConfig(raw, process.env);
+    const dedup = resolveDedupConfig(raw, process.env);
     const resolvedConfig = {
         provider,
         dbPath,
@@ -60,6 +61,7 @@ export function resolveMemoryConfig(config, worktree) {
             importanceWeight,
         },
         injection,
+        dedup,
         includeGlobalScope: toBoolean(process.env.LANCEDB_OPENCODE_PRO_INCLUDE_GLOBAL_SCOPE ?? raw.includeGlobalScope, true),
         globalDetectionThreshold: Math.max(1, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DETECTION_THRESHOLD ?? raw.globalDetectionThreshold, 2))),
         globalDiscountFactor: clamp(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DISCOUNT_FACTOR ?? raw.globalDiscountFactor, 0.7), 0, 1),
@@ -92,6 +94,13 @@ function resolveCodeTruncationMode(raw) {
         return raw;
     return "smart";
 }
+function resolveDedupConfig(raw, env) {
+    const dedupRaw = (raw.dedup ?? {});
+    const enabled = toBoolean(env.LANCEDB_OPENCODE_PRO_DEDUP_ENABLED ?? dedupRaw.enabled, true);
+    const writeThreshold = clamp(toNumber(env.LANCEDB_OPENCODE_PRO_DEDUP_WRITE_THRESHOLD ?? dedupRaw.writeThreshold, 0.92), 0.0, 1.0);
+    const consolidateThreshold = clamp(toNumber(env.LANCEDB_OPENCODE_PRO_DEDUP_CONSOLIDATE_THRESHOLD ?? dedupRaw.consolidateThreshold, 0.95), 0.0, 1.0);
+    return { enabled, writeThreshold, consolidateThreshold };
+}
 function resolveInjectionConfig(raw, env) {
     const injectionRaw = (raw.injection ?? {});
     const codeSummarizationRaw = (injectionRaw.codeSummarization ?? {});
@@ -178,6 +187,10 @@ function mergeMemoryConfig(base, override) {
                 ...((override.injection ?? {}).codeSummarization ?? {}),
             },
         },
+        dedup: {
+            ...(base.dedup ?? {}),
+            ...(override.dedup ?? {}),
+        },
     };
 }
 function firstString(...values) {

package/dist/index.js

@@ -23,6 +23,10 @@ const plugin = async (input) => {
             if (event.type === "session.idle" || event.type === "session.compacted") {
                 const sessionID = event.properties.sessionID;
                 await flushAutoCapture(sessionID, state, input.client);
+                if (event.type === "session.compacted" && state.config.dedup.enabled) {
+                    const activeScope = deriveProjectScope(input.worktree);
+                    state.store.consolidateDuplicates(activeScope, state.config.dedup.consolidateThreshold).catch(() => { });
+                }
             }
         },
         "experimental.text.complete": async (eventInput, eventOutput) => {
@@ -157,7 +161,9 @@ const plugin = async (input) => {
                     return results
                         .map((item, idx) => {
                         const percent = Math.round(item.score * 100);
-                        return `${idx + 1}. [${item.record.id}] (${item.record.scope}) ${item.record.text} [${percent}%]`;
+                        const meta = JSON.parse(item.record.metadataJson || "{}");
+                        const duplicateMarker = meta.isPotentialDuplicate ? " (duplicate)" : "";
+                        return `${idx + 1}. [${item.record.id}]${duplicateMarker} (${item.record.scope}) ${item.record.text} [${percent}%]`;
                     })
                         .join("\n");
                 },
@@ -429,6 +435,45 @@ const plugin = async (input) => {
                         .join("\n");
                 },
             }),
+            memory_consolidate: tool({
+                description: "Scope-internally merge near-duplicate memories. Use to clean up accumulated duplicates.",
+                args: {
+                    scope: tool.schema.string().optional(),
+                    confirm: tool.schema.boolean().default(false),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return unavailableMessage(state.config.embedding.provider);
+                    if (!args.confirm) {
+                        return "Rejected: memory_consolidate requires confirm=true.";
+                    }
+                    const targetScope = args.scope ?? deriveProjectScope(context.worktree);
+                    const result = await state.store.consolidateDuplicates(targetScope, state.config.dedup.consolidateThreshold);
+                    return JSON.stringify({ scope: targetScope, ...result }, null, 2);
+                },
+            }),
+            memory_consolidate_all: tool({
+                description: "Consolidate duplicates across global scope and current project scope. Used by external cron jobs for daily cleanup.",
+                args: {
+                    confirm: tool.schema.boolean().default(false),
+                },
+                execute: async (args, context) => {
+                    await state.ensureInitialized();
+                    if (!state.initialized)
+                        return unavailableMessage(state.config.embedding.provider);
+                    if (!args.confirm) {
+                        return "Rejected: memory_consolidate_all requires confirm=true.";
+                    }
+                    const projectScope = deriveProjectScope(context.worktree);
+                    const globalResult = await state.store.consolidateDuplicates("global", state.config.dedup.consolidateThreshold);
+                    const projectResult = await state.store.consolidateDuplicates(projectScope, state.config.dedup.consolidateThreshold);
+                    return JSON.stringify({
+                        global: { scope: "global", ...globalResult },
+                        project: { scope: projectScope, ...projectResult },
+                    }, null, 2);
+                },
+            }),
             memory_port_plan: tool({
                 description: "Plan non-conflicting host ports for compose services and optionally persist reservations",
                 args: {
@@ -638,6 +683,26 @@ async function flushAutoCapture(sessionID, state, client) {
         });
         return;
     }
+    let isPotentialDuplicate = false;
+    let duplicateOf = null;
+    if (state.config.dedup.enabled) {
+        const similar = await state.store.search({
+            query: result.candidate.text,
+            queryVector: vector,
+            scopes: [activeScope],
+            limit: 1,
+            vectorWeight: 1.0,
+            bm25Weight: 0.0,
+            minScore: 0.0,
+            rrfK: 60,
+            recencyBoost: false,
+            globalDiscountFactor: 1.0,
+        });
+        if (similar.length > 0 && similar[0].score >= state.config.dedup.writeThreshold) {
+            isPotentialDuplicate = true;
+            duplicateOf = similar[0].record.id;
+        }
+    }
     const memoryId = generateId();
     await state.store.put({
         id: memoryId,
@@ -656,6 +721,8 @@ async function flushAutoCapture(sessionID, state, client) {
         metadataJson: JSON.stringify({
             source: "auto-capture",
             sessionID,
+            isPotentialDuplicate,
+            duplicateOf,
         }),
     });
     await recordCaptureEvent(state, {

package/dist/store.d.ts

@@ -1,4 +1,5 @@
 import type { EffectivenessSummary, MemoryEffectivenessEvent, MemoryRecord, SearchResult } from "./types.js";
+export declare function storeFastCosine(a: number[], b: number[], normA: number, normB: number): number;
 export declare class MemoryStore {
     private readonly dbPath;
     private lancedb;
@@ -32,6 +33,11 @@ export declare class MemoryStore {
     clearScope(scope: string): Promise<number>;
     list(scope: string, limit: number): Promise<MemoryRecord[]>;
     pruneScope(scope: string, maxEntries: number): Promise<number>;
+    consolidateDuplicates(scope: string, threshold: number): Promise<{
+        mergedPairs: number;
+        updatedRecords: number;
+        skippedRecords: number;
+    }>;
     countIncompatibleVectors(scopes: string[], expectedDim: number): Promise<number>;
     private matchesId;
     hasMemory(id: string, scopes: string[]): Promise<boolean>;
@@ -48,6 +54,7 @@ export declare class MemoryStore {
     private requireTable;
     private requireEventTable;
     private readEventsByScopes;
+    private readByScopesIncludingMerged;
     private readByScopes;
     private ensureIndexes;
     private ensureMemoriesTableCompatibility;

package/dist/store.js

@@ -4,6 +4,19 @@ import { tokenize } from "./utils.js";
 const TABLE_NAME = "memories";
 const EVENTS_TABLE_NAME = "effectiveness_events";
 const EVENTS_SOURCE_COLUMN = "source";
+// Exported for use by consolidateDuplicates
+export function storeFastCosine(a, b, normA, normB) {
+    if (a.length === 0 || b.length === 0 || a.length !== b.length)
+        return 0;
+    const denom = normA * normB;
+    if (denom === 0)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        dot += a[i] * b[i];
+    }
+    return dot / denom;
+}
 export class MemoryStore {
     dbPath;
     lancedb = null;
@@ -209,13 +222,83 @@ export class MemoryStore {
         const rows = await this.list(scope, 100000);
         if (rows.length <= maxEntries)
             return 0;
-        const toDelete = rows.slice(maxEntries);
+        const flagged = rows.filter((r) => {
+            const meta = parseMetadata(r.metadataJson);
+            return meta.isPotentialDuplicate === true;
+        });
+        const unflagged = rows.filter((r) => {
+            const meta = parseMetadata(r.metadataJson);
+            return meta.isPotentialDuplicate !== true;
+        });
+        const sortedFlagged = flagged.sort((a, b) => a.timestamp - b.timestamp);
+        const sortedUnflagged = unflagged.sort((a, b) => a.timestamp - b.timestamp);
+        const toDeleteCount = rows.length - maxEntries;
+        const deleteFromFlagged = Math.min(sortedFlagged.length, toDeleteCount);
+        const toDelete = [
+            ...sortedFlagged.slice(0, deleteFromFlagged),
+            ...sortedUnflagged.slice(0, toDeleteCount - deleteFromFlagged),
+        ];
         for (const row of toDelete) {
             await this.requireTable().delete(`id = '${escapeSql(row.id)}'`);
         }
         this.invalidateScope(scope);
         return toDelete.length;
     }
+    async consolidateDuplicates(scope, threshold) {
+        const rows = await this.readByScopesIncludingMerged([scope]);
+        if (rows.length === 0) {
+            return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0 };
+        }
+        let mergedPairs = 0;
+        let updatedRecords = 0;
+        let skippedRecords = 0;
+        const now = Date.now();
+        const FIVE_MINUTES_MS = 5 * 60 * 1000;
+        const rowsWithNorms = rows.map((row) => ({
+            row,
+            norm: this.scopeCache.get(scope)?.norms.get(row.id) ?? vecNorm(row.vector),
+        }));
+        for (let i = 0; i < rowsWithNorms.length; i += 1) {
+            const a = rowsWithNorms[i];
+            for (let j = i + 1; j < rowsWithNorms.length; j += 1) {
+                const b = rowsWithNorms[j];
+                const sim = storeFastCosine(a.row.vector, b.row.vector, a.norm, b.norm);
+                if (sim < threshold)
+                    continue;
+                const aMeta = parseMetadata(a.row.metadataJson);
+                if (aMeta.status === "merged") {
+                    skippedRecords += 1;
+                    continue;
+                }
+                if (a.row.lastRecalled > 0 && now - a.row.lastRecalled < FIVE_MINUTES_MS) {
+                    skippedRecords += 1;
+                    continue;
+                }
+                const older = a.row.timestamp <= b.row.timestamp ? a.row : b.row;
+                const newer = a.row.timestamp <= b.row.timestamp ? b.row : a.row;
+                const newerMeta = parseMetadata(newer.metadataJson);
+                const mergedIntoId = newer.id;
+                const updatedOlderMeta = { status: "merged", mergedInto: mergedIntoId };
+                await this.requireTable().delete(`id = '${escapeSql(older.id)}'`);
+                await this.requireTable().add([{
+                        ...older,
+                        metadataJson: JSON.stringify({ ...parseMetadata(older.metadataJson), ...updatedOlderMeta }),
+                    }]);
+                const updatedNewerMeta = { ...newerMeta, mergedFrom: older.id };
+                await this.requireTable().delete(`id = '${escapeSql(newer.id)}'`);
+                await this.requireTable().add([{
+                        ...newer,
+                        metadataJson: JSON.stringify(updatedNewerMeta),
+                    }]);
+                mergedPairs += 1;
+                updatedRecords += 2;
+            }
+        }
+        if (mergedPairs > 0) {
+            this.invalidateScope(scope);
+        }
+        return { mergedPairs, updatedRecords, skippedRecords };
+    }
     async countIncompatibleVectors(scopes, expectedDim) {
         const rows = await this.readByScopes(scopes);
         return rows.filter((row) => row.vectorDim !== expectedDim).length;
@@ -279,6 +362,8 @@ export class MemoryStore {
     async summarizeEvents(scope, includeGlobalScope) {
         const scopes = includeGlobalScope && scope !== "global" ? [scope, "global"] : [scope];
         const events = await this.readEventsByScopes(scopes);
+        // Read all memories including merged for duplicate counts
+        const memories = await this.readByScopesIncludingMerged(scopes);
         const captureSkipReasons = {};
         let captureConsidered = 0;
         let captureStored = 0;
@@ -343,6 +428,15 @@ export class MemoryStore {
         }
         const totalCaptureAttempts = captureStored + captureSkipped;
         const totalUsefulFeedback = feedbackUsefulPositive + feedbackUsefulNegative;
+        // Count flagged (isPotentialDuplicate) and consolidated (status=merged) from memories table
+        const flaggedCount = memories.filter((r) => {
+            const meta = parseMetadata(r.metadataJson);
+            return meta.isPotentialDuplicate === true;
+        }).length;
+        const consolidatedCount = memories.filter((r) => {
+            const meta = parseMetadata(r.metadataJson);
+            return meta.status === "merged";
+        }).length;
         return {
             scope,
             totalEvents: events.length,
@@ -384,6 +478,10 @@ export class MemoryStore {
                 falsePositiveRate: captureStored === 0 ? 0 : feedbackWrong / captureStored,
                 falseNegativeRate: totalCaptureAttempts === 0 ? 0 : feedbackMissing / totalCaptureAttempts,
             },
+            duplicates: {
+                flaggedCount,
+                consolidatedCount,
+            },
         };
     }
     getIndexHealth() {
@@ -469,7 +567,7 @@ export class MemoryStore {
             .map((row) => normalizeEventRow(row))
             .filter((row) => row !== null);
     }
-    async readByScopes(scopes) {
+    async readByScopesIncludingMerged(scopes) {
         const table = this.requireTable();
         if (scopes.length === 0)
             return [];
@@ -499,6 +597,36 @@ export class MemoryStore {
             .map((row) => normalizeRow(row))
             .filter((row) => row !== null);
     }
+    async readByScopes(scopes) {
+        const table = this.requireTable();
+        if (scopes.length === 0)
+            return [];
+        const whereExpr = scopes.map((scope) => `scope = '${escapeSql(scope)}'`).join(" OR ");
+        const rows = await table
+            .query()
+            .where(`(${whereExpr}) AND metadataJson NOT LIKE '%"status":"merged"%'`)
+            .select([
+            "id",
+            "text",
+            "vector",
+            "category",
+            "scope",
+            "importance",
+            "timestamp",
+            "lastRecalled",
+            "recallCount",
+            "projectCount",
+            "schemaVersion",
+            "embeddingModel",
+            "vectorDim",
+            "metadataJson",
+        ])
+            .limit(100000)
+            .toArray();
+        return rows
+            .map((row) => normalizeRow(row))
+            .filter((row) => row !== null);
+    }
     async ensureIndexes() {
         const table = this.requireTable();
         try {
@@ -747,3 +875,11 @@ function extractRecalledProjects(metadataJson) {
     }
     return new Set();
 }
+function parseMetadata(metadataJson) {
+    try {
+        return JSON.parse(metadataJson);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/types.d.ts

@@ -16,7 +16,7 @@ export interface SummarizedContent {
 }
 export type MemoryCategory = "preference" | "fact" | "decision" | "entity" | "other";
 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 CaptureSkipReason = "empty-buffer" | "below-min-chars" | "no-positive-signal" | "initialization-unavailable" | "embedding-unavailable" | "empty-embedding" | "duplicate-similarity" | "duplicate-exact";
 export type FeedbackType = "missing" | "wrong" | "useful";
 export type RecallSource = "system-transform" | "manual-search";
 export type MemoryScope = "project" | "global";
@@ -67,12 +67,18 @@ export interface SummarizationConfig {
     preserveComments: boolean;
     preserveImports: boolean;
 }
+export interface DedupConfig {
+    enabled: boolean;
+    writeThreshold: number;
+    consolidateThreshold: number;
+}
 export interface MemoryRuntimeConfig {
     provider: string;
     dbPath: string;
     embedding: EmbeddingConfig;
     retrieval: RetrievalConfig;
     injection: InjectionConfig;
+    dedup: DedupConfig;
     includeGlobalScope: boolean;
     globalDetectionThreshold: number;
     globalDiscountFactor: number;
@@ -180,5 +186,9 @@ export interface EffectivenessSummary {
         falsePositiveRate: number;
         falseNegativeRate: number;
     };
+    duplicates: {
+        flaggedCount: number;
+        consolidatedCount: number;
+    };
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lancedb-opencode-pro",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Jonathan Tsai <tryweb@ichiayi.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.