lancedb-opencode-pro 0.2.3 → 0.2.5

package/README.md

@@ -240,6 +240,17 @@ Supported environment variables:
 - `LANCEDB_OPENCODE_PRO_UNUSED_DAYS_THRESHOLD`
 - `LANCEDB_OPENCODE_PRO_MIN_CAPTURE_CHARS`
 - `LANCEDB_OPENCODE_PRO_MAX_ENTRIES_PER_SCOPE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS_PER_MEMORY`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_INJECTION_FLOOR`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_PRESERVE_STRUCTURE`
 
 ## What It Provides
 
@@ -357,6 +368,158 @@ Recommended review order in low-feedback environments:
 3. Check whether users still needed manual rescue through `memory_search` or issued correction-like responses.
 4. Run a bounded audit of recalled memories or skipped captures before concluding the system is helping.
 
+## Injection Control
+
+This provider supports configurable memory injection behavior, allowing you to control how recalled memories are processed before being injected into the LLM prompt.
+
+### Configuration
+
+Add an `injection` block to your sidecar config:
+
+```json
+{
+  "provider": "lancedb-opencode-pro",
+  "injection": {
+    "mode": "fixed",
+    "maxMemories": 3,
+    "minMemories": 1,
+    "budgetTokens": 4096,
+    "maxCharsPerMemory": 1200,
+    "summarization": "none",
+    "summaryTargetChars": 300,
+    "scoreDropTolerance": 0.15,
+    "injectionFloor": 0.2,
+    "codeSummarization": {
+      "mode": "smart",
+      "preserveStructure": true
+    }
+  }
+}
+```
+
+### Injection Modes
+
+- **`fixed`** (default) — Always inject up to `maxMemories` memories regardless of content size. This preserves backward-compatible behavior.
+- **`budget`** — Limit total injected tokens to `budgetTokens`. The provider accumulates memories until the token budget is exhausted.
+- **`adaptive`** — Dynamically adjust injection count based on score drops. Stop injection when scores drop below `scoreDropTolerance` relative to the highest-scored memory.
+
+### Summarization Modes
+
+When `summarization` is set to `truncate` or `extract`, memories are summarized before injection:
+
+- **`none`** (default) — No summarization; inject full text.
+- **`truncate`** — Simple truncation to `summaryTargetChars` with ellipsis.
+- **`extract`** — Key sentence extraction for text, structure-preserving truncation for code.
+- **`auto`** — Content-aware summarization (truncate for text, preserve structure for code).
+
+### Code Handling
+
+The `codeSummarization` config controls how code snippets are processed:
+
+- **`mode`**: `"smart"` | `"truncate"` | `"preserve"` (default: `"smart"`)
+- **`preserveStructure`**: When `true`, code truncation attempts to balance brackets and preserve syntactic validity.
+
+### Environment Variables
+
+All injection options can be overridden via environment variables:
+
+- `LANCEDB_OPENCODE_PRO_INJECTION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS_PER_MEMORY`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_INJECTION_FLOOR`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_PRESERVE_STRUCTURE`
+
+### Default Behavior
+
+The default configuration preserves backward compatibility:
+
+- `mode`: `"fixed"`
+- `maxMemories`: `3`
+- `summarization`: `"none"`
+
+This means without any `injection` configuration, the provider behaves identically to previous versions: always inject up to 3 memories with full text.
+
+### Example: Token Budget Mode
+
+For token-sensitive deployments, use budget mode to limit context size:
+
+```json
+{
+  "injection": {
+    "mode": "budget",
+    "budgetTokens": 1500,
+    "summarization": "truncate",
+    "summaryTargetChars": 400
+  }
+}
+```
+
+This configuration:
+1. Accumulates memories until total estimated tokens reach ~1500
+2. Truncates each memory to ~400 characters before injection
+3. Guarantees at least 1 memory is always included
+
+### Example: Adaptive Mode
+
+For quality-sensitive scenarios where you want to avoid low-relevance memories:
+
+```json
+{
+  "injection": {
+    "mode": "adaptive",
+    "maxMemories": 5,
+    "minMemories": 2,
+    "scoreDropTolerance": 0.15,
+    "injectionFloor": 0.2
+  }
+}
+```
+
+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 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
+
+---
+
 ## OpenAI Embedding Configuration
 
 Default behavior stays on Ollama. To use OpenAI embeddings, set `embedding.provider` to `openai` and provide API key + model.
@@ -500,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
@@ -512,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:
@@ -568,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
@@ -578,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
@@ -596,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
@@ -622,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:
@@ -651,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.
@@ -667,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
@@ -676,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.
@@ -686,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

@@ -38,6 +38,8 @@ export function resolveMemoryConfig(config, worktree) {
         ? process.env.LANCEDB_OPENCODE_PRO_OPENAI_TIMEOUT_MS ?? process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS
         : 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,
@@ -58,6 +60,8 @@ export function resolveMemoryConfig(config, worktree) {
             recencyHalfLifeHours,
             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),
@@ -75,6 +79,51 @@ function resolveEmbeddingProvider(raw) {
         return "openai";
     throw new Error(`[lancedb-opencode-pro] Invalid embedding provider "${raw}". Expected "ollama" or "openai".`);
 }
+function resolveInjectionMode(raw) {
+    if (raw === "fixed" || raw === "budget" || raw === "adaptive")
+        return raw;
+    return "fixed";
+}
+function resolveSummarizationMode(raw) {
+    if (raw === "none" || raw === "truncate" || raw === "extract" || raw === "auto")
+        return raw;
+    return "none";
+}
+function resolveCodeTruncationMode(raw) {
+    if (raw === "smart" || raw === "signature" || raw === "preserve")
+        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 ?? {});
+    return {
+        mode: resolveInjectionMode(env.LANCEDB_OPENCODE_PRO_INJECTION_MODE ?? injectionRaw.mode),
+        maxMemories: Math.max(1, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES ?? injectionRaw.maxMemories, 3))),
+        minMemories: Math.max(1, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES ?? injectionRaw.minMemories, 1))),
+        budgetTokens: Math.max(256, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS ?? injectionRaw.budgetTokens, 4096))),
+        maxCharsPerMemory: Math.max(100, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS ?? injectionRaw.maxCharsPerMemory, 1200))),
+        summarization: resolveSummarizationMode(env.LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION ?? injectionRaw.summarization),
+        summaryTargetChars: Math.max(50, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS ?? injectionRaw.summaryTargetChars, 300))),
+        scoreDropTolerance: clamp(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE ?? injectionRaw.scoreDropTolerance, 0.15), 0, 1),
+        injectionFloor: clamp(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_FLOOR ?? injectionRaw.injectionFloor, 0.2), 0, 1),
+        codeSummarization: {
+            enabled: toBoolean(env.LANCEDB_OPENCODE_PRO_CODE_SUMMARIZATION_ENABLED ?? codeSummarizationRaw.enabled, true),
+            pureCodeThreshold: Math.max(100, Math.floor(toNumber(codeSummarizationRaw.pureCodeThreshold, 500))),
+            maxCodeLines: Math.max(5, Math.floor(toNumber(codeSummarizationRaw.maxCodeLines, 15))),
+            codeTruncationMode: resolveCodeTruncationMode(codeSummarizationRaw.codeTruncationMode),
+            preserveComments: toBoolean(codeSummarizationRaw.preserveComments, true),
+            preserveImports: toBoolean(codeSummarizationRaw.preserveImports, false),
+        },
+    };
+}
 function validateEmbeddingConfig(embedding) {
     if (embedding.provider !== "openai")
         return;
@@ -130,6 +179,18 @@ function mergeMemoryConfig(base, override) {
             ...(base.retrieval ?? {}),
             ...(override.retrieval ?? {}),
         },
+        injection: {
+            ...(base.injection ?? {}),
+            ...(override.injection ?? {}),
+            codeSummarization: {
+                ...((base.injection ?? {}).codeSummarization ?? {}),
+                ...((override.injection ?? {}).codeSummarization ?? {}),
+            },
+        },
+        dedup: {
+            ...(base.dedup ?? {}),
+            ...(override.dedup ?? {}),
+        },
     };
 }
 function firstString(...values) {

package/dist/index.js

@@ -6,6 +6,7 @@ import { isTcpPortAvailable, parsePortReservations, planPorts, reservationKey }
 import { buildScopeFilter, deriveProjectScope } from "./scope.js";
 import { MemoryStore } from "./store.js";
 import { generateId } from "./utils.js";
+import { calculateInjectionLimit, createSummarizationConfig, summarizeContent } from "./summarize.js";
 const SCHEMA_VERSION = 1;
 const plugin = async (input) => {
     const state = await createRuntimeState(input);
@@ -22,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) => {
@@ -52,16 +57,19 @@ const plugin = async (input) => {
                 query,
                 queryVector,
                 scopes,
-                limit: 3,
+                limit: state.config.injection.maxMemories * 2, // Fetch more than needed for filtering
                 vectorWeight: state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight,
                 bm25Weight: state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight,
-                minScore: state.config.retrieval.minScore,
+                minScore: Math.max(state.config.retrieval.minScore, state.config.injection.injectionFloor),
                 rrfK: state.config.retrieval.rrfK,
                 recencyBoost: state.config.retrieval.recencyBoost,
                 recencyHalfLifeHours: state.config.retrieval.recencyHalfLifeHours,
                 importanceWeight: state.config.retrieval.importanceWeight,
                 globalDiscountFactor: state.config.globalDiscountFactor,
             });
+            // Apply injection control
+            const injectionLimit = calculateInjectionLimit(results, state.config.injection);
+            const limitedResults = results.slice(0, injectionLimit);
             await state.store.putEvent({
                 id: generateId(),
                 type: "recall",
@@ -69,21 +77,32 @@ const plugin = async (input) => {
                 scope: activeScope,
                 sessionID: eventInput.sessionID,
                 timestamp: Date.now(),
-                resultCount: results.length,
-                injected: results.length > 0,
+                resultCount: limitedResults.length,
+                injected: limitedResults.length > 0,
                 metadataJson: JSON.stringify({
                     source: "system-transform",
                     includeGlobalScope: state.config.includeGlobalScope,
+                    injectionMode: state.config.injection.mode,
+                    injectionLimit: injectionLimit,
                 }),
             });
-            if (results.length === 0)
+            if (limitedResults.length === 0)
                 return;
-            for (const result of results) {
+            for (const result of limitedResults) {
                 state.store.updateMemoryUsage(result.record.id, activeScope, scopes).catch(() => { });
             }
+            // Apply summarization if configured
+            const summarizationConfig = createSummarizationConfig(state.config.injection);
+            const processedResults = limitedResults.map((item) => {
+                if (state.config.injection.summarization === "none") {
+                    return { ...item, text: item.record.text };
+                }
+                const summarized = summarizeContent(item.record.text, summarizationConfig);
+                return { ...item, text: summarized.content };
+            });
             const memoryBlock = [
                 "[Memory Recall - optional historical context]",
-                ...results.map((item, index) => `${index + 1}. [${item.record.id}] (${item.record.scope}) ${item.record.text}`),
+                ...processedResults.map((item, index) => `${index + 1}. [${item.record.id}] (${item.record.scope}) ${item.text}`),
                 "Use these as optional hints only; prioritize current user intent and current repo state.",
             ].join("\n");
             eventOutput.system.push(memoryBlock);
@@ -142,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");
                 },
@@ -414,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: {
@@ -623,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,
@@ -641,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/summarize.d.ts

@@ -0,0 +1,52 @@
+import type { ContentType, ContentDetection, SummarizedContent, SummarizationConfig, InjectionConfig, SearchResult } from "./types.js";
+/**
+ * Detects whether content contains code and its type
+ */
+export declare function detectContentType(text: string): ContentDetection;
+/**
+ * Calculates bracket balance for code detection
+ */
+export declare function calculateBracketBalance(text: string): number;
+/**
+ * Counts code-related keywords
+ */
+export declare function countCodeKeywords(text: string): number;
+/**
+ * Calculates ratio of indented lines
+ */
+export declare function calculateIndentationRatio(text: string): number;
+/**
+ * Estimates token count for content
+ */
+export declare function estimateTokens(text: string, contentType: ContentType): number;
+/**
+ * Truncates text to max characters
+ */
+export declare function truncateText(text: string, maxChars: number): string;
+/**
+ * Smart truncation for code - finds complete statement boundaries
+ */
+export declare function smartTruncateCode(code: string, maxLines: number, config?: {
+    preserveComments?: boolean;
+    preserveImports?: boolean;
+}): string;
+/**
+ * Extracts key sentences from text
+ */
+export declare function extractKeySentences(text: string, targetChars: number): string;
+export declare function splitCodeAndText(text: string): Array<{
+    type: "code" | "text";
+    content: string;
+}>;
+/**
+ * Main summarization function
+ */
+export declare function summarizeContent(text: string, config: SummarizationConfig): SummarizedContent;
+/**
+ * Calculates injection limit based on mode
+ */
+export declare function calculateInjectionLimit(results: SearchResult[], config: InjectionConfig): number;
+/**
+ * Creates default summarization config from injection config
+ */
+export declare function createSummarizationConfig(injection: InjectionConfig): SummarizationConfig;

package/dist/summarize.js

@@ -0,0 +1,350 @@
+// Code keywords used for content detection
+const CODE_KEYWORDS = [
+    "function", "async", "await", "const", "let", "var", "return", "class", "interface", "type",
+    "import", "export", "from", "default", "extends", "implements", "new", "this", "super",
+    "def ", "async def", "func ", "fn ", "pub fn", "impl ", "struct ", "enum ",
+    "=>", "->", "::", "if (", "for (", "while (", "try {", "catch (", "throw ",
+];
+// Keywords for key sentence extraction
+const KEY_SENTENCE_PATTERNS = [
+    /(?:fixed|resolved|works?\s+now|successful|done|完成|已解決|修復|成功)/i,
+    /(?:probleme|issue|bug|error|fail|錯誤|問題|失敗)/i,
+    /(?:solution|fix|resolve|解決方案|修正)/i,
+    /(?:because|root\s+cause|原因|由於)/i,
+    /(?:decide|decision|tradeoff|architecture|決定|架構|採用)/i,
+    /(?:prefer|preference|偏好|習慣)/i,
+];
+/**
+ * Detects whether content contains code and its type
+ */
+export function detectContentType(text) {
+    const hasMarkdownCode = /```[\s\S]*?```/.test(text);
+    const bracketBalance = calculateBracketBalance(text);
+    const codeKeywords = countCodeKeywords(text);
+    const indentationRatio = calculateIndentationRatio(text);
+    const codeScore = (hasMarkdownCode ? 2 : 0) +
+        (bracketBalance > 3 ? 1 : 0) +
+        (codeKeywords > 5 ? 1 : 0) +
+        (indentationRatio > 0.3 ? 1 : 0);
+    if (codeScore >= 5) {
+        return { hasCode: true, isPureCode: true };
+    }
+    if (codeScore >= 3) {
+        return { hasCode: true, isPureCode: false };
+    }
+    if (hasMarkdownCode || codeKeywords > 10) {
+        return { hasCode: true, isPureCode: false };
+    }
+    return { hasCode: false, isPureCode: false };
+}
+/**
+ * Calculates bracket balance for code detection
+ */
+export function calculateBracketBalance(text) {
+    const openBrackets = (text.match(/[{([]/g) || []).length;
+    const closeBrackets = (text.match(/[})\]]/g) || []).length;
+    return Math.abs(openBrackets - closeBrackets) + Math.min(openBrackets, closeBrackets);
+}
+/**
+ * Counts code-related keywords
+ */
+export function countCodeKeywords(text) {
+    const lower = text.toLowerCase();
+    let count = 0;
+    for (const keyword of CODE_KEYWORDS) {
+        if (lower.includes(keyword.toLowerCase())) {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * Calculates ratio of indented lines
+ */
+export function calculateIndentationRatio(text) {
+    const lines = text.split("\n");
+    if (lines.length === 0)
+        return 0;
+    const indentedLines = lines.filter((line) => /^\s{2,}/.test(line));
+    return indentedLines.length / lines.length;
+}
+/**
+ * Estimates token count for content
+ */
+export function estimateTokens(text, contentType) {
+    // Count Chinese characters
+    const chineseChars = (text.match(/[\u4e00-\u9fff]/g) || []).length;
+    const nonChineseChars = text.length - chineseChars;
+    // Chinese ~2 chars/token, English/other ~4 chars/token
+    const baseTokens = Math.ceil(chineseChars / 2 + nonChineseChars / 4);
+    // Code has higher token density
+    if (contentType === "code") {
+        return Math.ceil(baseTokens * 1.2);
+    }
+    return baseTokens;
+}
+/**
+ * Truncates text to max characters
+ */
+export function truncateText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+/**
+ * Smart truncation for code - finds complete statement boundaries
+ */
+export function smartTruncateCode(code, maxLines, config) {
+    const lines = code.split("\n");
+    if (lines.length <= maxLines)
+        return code;
+    let braceBalance = 0;
+    let lastCompleteIndex = maxLines;
+    let foundComplete = false;
+    // Calculate brace balance and find last complete statement
+    for (let i = 0; i < Math.min(lines.length, maxLines + 10); i++) {
+        const line = lines[i];
+        braceBalance += (line.match(/{/g) || []).length;
+        braceBalance -= (line.match(/}/g) || []).length;
+        if (i >= maxLines - 5 && braceBalance === 0 && i < lines.length - 1) {
+            lastCompleteIndex = i + 1;
+            foundComplete = true;
+            break;
+        }
+    }
+    // If no complete boundary found, use maxLines
+    if (!foundComplete) {
+        lastCompleteIndex = maxLines;
+    }
+    // Build truncated code
+    let result = lines.slice(0, lastCompleteIndex).join("\n");
+    // Add truncation indicator
+    result += "\n// ... (truncated)";
+    return result;
+}
+/**
+ * Extracts key sentences from text
+ */
+export function extractKeySentences(text, targetChars) {
+    const sentences = text.split(/[。.!?\n]+/).filter((s) => s.trim().length > 0);
+    const keySentences = [];
+    let currentLength = 0;
+    // First pass: sentences matching key patterns
+    for (const sentence of sentences) {
+        const trimmed = sentence.trim();
+        if (KEY_SENTENCE_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+            if (currentLength + trimmed.length > targetChars && keySentences.length > 0) {
+                break;
+            }
+            keySentences.push(trimmed);
+            currentLength += trimmed.length + 1;
+        }
+    }
+    // Second pass: fill remaining with first sentences if needed
+    if (currentLength < targetChars * 0.5) {
+        for (const sentence of sentences) {
+            const trimmed = sentence.trim();
+            if (!keySentences.includes(trimmed)) {
+                if (currentLength + trimmed.length > targetChars) {
+                    break;
+                }
+                keySentences.push(trimmed);
+                currentLength += trimmed.length + 1;
+            }
+        }
+    }
+    return keySentences.join(" → ");
+}
+export function splitCodeAndText(text) {
+    const parts = [];
+    const codeBlockRegex = /```[\s\S]*?```/g;
+    let lastIndex = 0;
+    let match = codeBlockRegex.exec(text);
+    while (match !== null) {
+        if (match.index > lastIndex) {
+            const textPart = text.slice(lastIndex, match.index).trim();
+            if (textPart) {
+                parts.push({ type: "text", content: textPart });
+            }
+        }
+        parts.push({ type: "code", content: match[0] });
+        lastIndex = match.index + match[0].length;
+        match = codeBlockRegex.exec(text);
+    }
+    if (lastIndex < text.length) {
+        const remaining = text.slice(lastIndex).trim();
+        if (remaining) {
+            parts.push({ type: "text", content: remaining });
+        }
+    }
+    return parts;
+}
+/**
+ * Main summarization function
+ */
+export function summarizeContent(text, config) {
+    const detection = detectContentType(text);
+    const originalLength = text.length;
+    // Determine content type
+    const contentType = detection.isPureCode
+        ? "code"
+        : detection.hasCode
+            ? "mixed"
+            : "text";
+    // No summarization
+    if (config.mode === "none") {
+        return {
+            type: "kept",
+            content: truncateText(text, config.textThreshold * 4), // Max chars limit
+            originalLength,
+            estimatedTokens: estimateTokens(text, contentType),
+        };
+    }
+    // Pure text
+    if (contentType === "text") {
+        if (text.length <= config.textThreshold) {
+            return {
+                type: "kept",
+                content: text,
+                originalLength,
+                estimatedTokens: estimateTokens(text, contentType),
+            };
+        }
+        if (config.mode === "truncate") {
+            const truncated = truncateText(text, config.summaryTargetChars);
+            return {
+                type: "truncated",
+                content: truncated,
+                originalLength,
+                estimatedTokens: estimateTokens(truncated, contentType),
+            };
+        }
+        const extracted = extractKeySentences(text, config.summaryTargetChars);
+        return {
+            type: "summarized",
+            content: extracted,
+            originalLength,
+            estimatedTokens: estimateTokens(extracted, contentType),
+        };
+    }
+    // Pure code
+    if (contentType === "code") {
+        if (text.length <= config.codeThreshold) {
+            return {
+                type: "kept",
+                content: text,
+                originalLength,
+                estimatedTokens: estimateTokens(text, contentType),
+            };
+        }
+        const truncated = smartTruncateCode(text, config.maxCodeLines, {
+            preserveComments: config.preserveComments,
+            preserveImports: config.preserveImports,
+        });
+        return {
+            type: "truncated",
+            content: truncated,
+            originalLength,
+            estimatedTokens: estimateTokens(truncated, contentType),
+        };
+    }
+    // Mixed content
+    if (config.mode === "auto" || config.mode === "extract") {
+        const parts = splitCodeAndText(text);
+        const summarizedParts = [];
+        for (const part of parts) {
+            if (part.type === "text") {
+                if (part.content.length <= config.textThreshold) {
+                    summarizedParts.push(part.content);
+                }
+                else {
+                    summarizedParts.push(extractKeySentences(part.content, config.summaryTargetChars / 2));
+                }
+            }
+            else {
+                if (part.content.length <= config.codeThreshold) {
+                    summarizedParts.push(part.content);
+                }
+                else {
+                    summarizedParts.push(smartTruncateCode(part.content, config.maxCodeLines));
+                }
+            }
+        }
+        return {
+            type: "mixed",
+            content: summarizedParts.join("\n\n"),
+            originalLength,
+            estimatedTokens: estimateTokens(summarizedParts.join("\n\n"), contentType),
+        };
+    }
+    // Fallback: truncate
+    return {
+        type: "truncated",
+        content: truncateText(text, config.summaryTargetChars),
+        originalLength,
+        estimatedTokens: estimateTokens(truncateText(text, config.summaryTargetChars), contentType),
+    };
+}
+/**
+ * Calculates injection limit based on mode
+ */
+export function calculateInjectionLimit(results, config) {
+    // Filter by injection floor
+    const filteredResults = results.filter((r) => r.score >= config.injectionFloor);
+    // Fixed mode: simple limit
+    if (config.mode === "fixed") {
+        return Math.min(config.maxMemories, filteredResults.length);
+    }
+    // Budget mode: accumulate until budget exhausted
+    if (config.mode === "budget") {
+        let accumulatedTokens = 0;
+        let count = 0;
+        for (const result of filteredResults) {
+            const tokens = estimateTokens(result.record.text, detectContentType(result.record.text).isPureCode ? "code" : "text");
+            if (accumulatedTokens + tokens > config.budgetTokens && count >= config.minMemories) {
+                break;
+            }
+            accumulatedTokens += tokens;
+            count += 1;
+            if (count >= config.maxMemories) {
+                break;
+            }
+        }
+        return Math.max(config.minMemories, Math.min(count, config.maxMemories));
+    }
+    // Adaptive mode: stop on score drop
+    if (config.mode === "adaptive") {
+        let count = 0;
+        let prevScore = filteredResults[0]?.score ?? 0;
+        for (const result of filteredResults) {
+            const scoreDrop = prevScore - result.score;
+            // Stop if score drops below tolerance (but respect minimum)
+            if (scoreDrop > config.scoreDropTolerance && count >= config.minMemories) {
+                break;
+            }
+            count += 1;
+            prevScore = result.score;
+            if (count >= config.maxMemories) {
+                break;
+            }
+        }
+        return Math.max(config.minMemories, Math.min(count, filteredResults.length));
+    }
+    // Fallback
+    return Math.min(config.maxMemories, filteredResults.length);
+}
+/**
+ * Creates default summarization config from injection config
+ */
+export function createSummarizationConfig(injection) {
+    return {
+        mode: injection.summarization,
+        textThreshold: 300,
+        codeThreshold: injection.codeSummarization.pureCodeThreshold,
+        summaryTargetChars: injection.summaryTargetChars,
+        maxCodeLines: injection.codeSummarization.maxCodeLines,
+        codeTruncationMode: injection.codeSummarization.codeTruncationMode,
+        preserveComments: injection.codeSummarization.preserveComments,
+        preserveImports: injection.codeSummarization.preserveImports,
+    };
+}

package/dist/types.d.ts

@@ -1,8 +1,22 @@
 export type EmbeddingProvider = "ollama" | "openai";
 export type RetrievalMode = "hybrid" | "vector";
+export type InjectionMode = "fixed" | "budget" | "adaptive";
+export type SummarizationMode = "none" | "truncate" | "extract" | "auto";
+export type CodeTruncationMode = "smart" | "signature" | "preserve";
+export type ContentType = "text" | "code" | "mixed";
+export interface ContentDetection {
+    hasCode: boolean;
+    isPureCode: boolean;
+}
+export interface SummarizedContent {
+    type: "kept" | "truncated" | "summarized" | "mixed";
+    content: string;
+    originalLength: number;
+    estimatedTokens: number;
+}
 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";
@@ -23,11 +37,48 @@ export interface RetrievalConfig {
     recencyHalfLifeHours: number;
     importanceWeight: number;
 }
+export interface CodeSummarizationConfig {
+    enabled: boolean;
+    pureCodeThreshold: number;
+    maxCodeLines: number;
+    codeTruncationMode: CodeTruncationMode;
+    preserveComments: boolean;
+    preserveImports: boolean;
+}
+export interface InjectionConfig {
+    mode: InjectionMode;
+    maxMemories: number;
+    minMemories: number;
+    budgetTokens: number;
+    maxCharsPerMemory: number;
+    summarization: SummarizationMode;
+    summaryTargetChars: number;
+    scoreDropTolerance: number;
+    injectionFloor: number;
+    codeSummarization: CodeSummarizationConfig;
+}
+export interface SummarizationConfig {
+    mode: SummarizationMode;
+    textThreshold: number;
+    codeThreshold: number;
+    summaryTargetChars: number;
+    maxCodeLines: number;
+    codeTruncationMode: CodeTruncationMode;
+    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;
@@ -135,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.3",
+  "version": "0.2.5",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",