@totalreclaw/totalreclaw 3.3.12 → 3.3.13-rc.1

package/dist/{claims-helper.js → extraction/claims-helper.js}

@@ -10,8 +10,8 @@
  */
 import crypto from 'node:crypto';
 import { createRequire } from 'node:module';
-import { isValidMemoryType, isValidMemoryTypeV1, V0_TO_V1_TYPE, VALID_MEMORY_SCOPES, VALID_MEMORY_SOURCES, VALID_MEMORY_VOLATILITIES, VALID_MEMORY_TYPES_V1, } from './extractor.js';
-import { envStringLower } from './entry.js';
+import { isValidMemoryType, V0_TO_V1_TYPE, VALID_MEMORY_SCOPES, VALID_MEMORY_SOURCES, VALID_MEMORY_VOLATILITIES, } from './extractor.js';
+import { envStringLower } from '../entry.js';
 // Lazy-load WASM. We use createRequire so this module loads cleanly under
 // both the OpenClaw runtime (CJS-ish tsx) and bare Node ESM (used by tests).
 const requireWasm = createRequire(import.meta.url);
@@ -285,28 +285,28 @@ export function isV1Blob(decrypted) {
 }
 export function readV1Blob(decrypted) {
     try {
-        const obj = JSON.parse(decrypted);
-        if (typeof obj.schema_version !== 'string' || !obj.schema_version.startsWith('1.')) {
+        const decodedBlob = JSON.parse(decrypted);
+        if (typeof decodedBlob.schema_version !== 'string' || !decodedBlob.schema_version.startsWith('1.')) {
             return null;
         }
-        const text = typeof obj.text === 'string' ? obj.text : '';
-        const rawType = typeof obj.type === 'string' ? obj.type : 'claim';
-        const type = isValidMemoryTypeV1(rawType) ? rawType : 'claim';
-        const rawSource = typeof obj.source === 'string' ? obj.source : 'user-inferred';
+        const text = typeof decodedBlob.text === 'string' ? decodedBlob.text : '';
+        const rawType = typeof decodedBlob.type === 'string' ? decodedBlob.type : 'claim';
+        const type = isValidMemoryType(rawType) ? rawType : 'claim';
+        const rawSource = typeof decodedBlob.source === 'string' ? decodedBlob.source : 'user-inferred';
         const source = VALID_MEMORY_SOURCES.includes(rawSource)
             ? rawSource
             : 'user-inferred';
-        const rawScope = typeof obj.scope === 'string' ? obj.scope : 'unspecified';
+        const rawScope = typeof decodedBlob.scope === 'string' ? decodedBlob.scope : 'unspecified';
         const scope = VALID_MEMORY_SCOPES.includes(rawScope)
             ? rawScope
             : 'unspecified';
-        const rawVolatility = typeof obj.volatility === 'string' ? obj.volatility : 'updatable';
+        const rawVolatility = typeof decodedBlob.volatility === 'string' ? decodedBlob.volatility : 'updatable';
         const volatility = VALID_MEMORY_VOLATILITIES.includes(rawVolatility)
             ? rawVolatility
             : 'updatable';
-        const impRaw = typeof obj.importance === 'number' ? obj.importance : 5;
+        const impRaw = typeof decodedBlob.importance === 'number' ? decodedBlob.importance : 5;
         const importance = Math.max(1, Math.min(10, Math.round(impRaw)));
-        const confRaw = typeof obj.confidence === 'number' ? obj.confidence : 0.85;
+        const confRaw = typeof decodedBlob.confidence === 'number' ? decodedBlob.confidence : 0.85;
         const confidence = Math.max(0, Math.min(1, confRaw));
         const result = {
             text,
@@ -316,25 +316,25 @@ export function readV1Blob(decrypted) {
             volatility,
             importance,
             confidence,
-            createdAt: typeof obj.created_at === 'string' ? obj.created_at : '',
+            createdAt: typeof decodedBlob.created_at === 'string' ? decodedBlob.created_at : '',
         };
-        if (typeof obj.reasoning === 'string' && obj.reasoning.length > 0) {
-            result.reasoning = obj.reasoning;
+        if (typeof decodedBlob.reasoning === 'string' && decodedBlob.reasoning.length > 0) {
+            result.reasoning = decodedBlob.reasoning;
         }
-        if (Array.isArray(obj.entities)) {
-            result.entities = obj.entities.filter((e) => !!e &&
+        if (Array.isArray(decodedBlob.entities)) {
+            result.entities = decodedBlob.entities.filter((e) => !!e &&
                 typeof e === 'object' &&
                 typeof e.name === 'string' &&
                 typeof e.type === 'string');
         }
-        if (typeof obj.expires_at === 'string')
-            result.expiresAt = obj.expires_at;
-        if (typeof obj.superseded_by === 'string')
-            result.supersededBy = obj.superseded_by;
-        if (typeof obj.id === 'string')
-            result.id = obj.id;
-        if (typeof obj.pin_status === 'string') {
-            const ps = obj.pin_status;
+        if (typeof decodedBlob.expires_at === 'string')
+            result.expiresAt = decodedBlob.expires_at;
+        if (typeof decodedBlob.superseded_by === 'string')
+            result.supersededBy = decodedBlob.superseded_by;
+        if (typeof decodedBlob.id === 'string')
+            result.id = decodedBlob.id;
+        if (typeof decodedBlob.pin_status === 'string') {
+            const ps = decodedBlob.pin_status;
             if (ps === 'pinned' || ps === 'unpinned') {
                 result.pinStatus = ps;
             }
@@ -342,8 +342,8 @@ export function readV1Blob(decrypted) {
         // 3.3.1-rc.22 — pull the embedder identity tag through. Plugin-only
         // field added by `buildCanonicalClaimV1` / `buildV1ClaimBlob` after
         // core validation.
-        if (typeof obj.embedding_model_id === 'string' && obj.embedding_model_id.length > 0) {
-            result.embeddingModelId = obj.embedding_model_id;
+        if (typeof decodedBlob.embedding_model_id === 'string' && decodedBlob.embedding_model_id.length > 0) {
+            result.embeddingModelId = decodedBlob.embedding_model_id;
         }
         return result;
     }
@@ -351,10 +351,6 @@ export function readV1Blob(decrypted) {
         return null;
     }
 }
-// Suppress unused-import lint warnings for VALID_MEMORY_TYPES_V1 — it is
-// exported from extractor.ts for downstream clients and kept in scope here
-// so future v1 helpers can reuse it without re-importing.
-void VALID_MEMORY_TYPES_V1;
 // ---------------------------------------------------------------------------
 // Back-compat alias: buildCanonicalClaimRouted
 //
@@ -421,56 +417,56 @@ export function resolveAutoResolveMode() {
 }
 export function readClaimFromBlob(decryptedJson) {
     try {
-        const obj = JSON.parse(decryptedJson);
+        const decodedBlob = JSON.parse(decryptedJson);
         // v1 payload: long-form fields + schema_version "1.x"
-        if (typeof obj.text === 'string' &&
-            typeof obj.type === 'string' &&
-            typeof obj.schema_version === 'string' &&
-            obj.schema_version.startsWith('1.')) {
-            const importance = typeof obj.importance === 'number'
-                ? Math.max(1, Math.min(10, Math.round(obj.importance)))
+        if (typeof decodedBlob.text === 'string' &&
+            typeof decodedBlob.type === 'string' &&
+            typeof decodedBlob.schema_version === 'string' &&
+            decodedBlob.schema_version.startsWith('1.')) {
+            const importance = typeof decodedBlob.importance === 'number'
+                ? Math.max(1, Math.min(10, Math.round(decodedBlob.importance)))
                 : 5;
             return {
-                text: obj.text,
+                text: decodedBlob.text,
                 importance,
-                category: mapTypeToCategory(obj.type),
+                category: mapTypeToCategory(decodedBlob.type),
                 metadata: {
-                    type: obj.type,
-                    source: typeof obj.source === 'string' ? obj.source : 'user-inferred',
-                    scope: typeof obj.scope === 'string' ? obj.scope : 'unspecified',
-                    volatility: typeof obj.volatility === 'string' ? obj.volatility : 'updatable',
-                    reasoning: typeof obj.reasoning === 'string' ? obj.reasoning : undefined,
+                    type: decodedBlob.type,
+                    source: typeof decodedBlob.source === 'string' ? decodedBlob.source : 'user-inferred',
+                    scope: typeof decodedBlob.scope === 'string' ? decodedBlob.scope : 'unspecified',
+                    volatility: typeof decodedBlob.volatility === 'string' ? decodedBlob.volatility : 'updatable',
+                    reasoning: typeof decodedBlob.reasoning === 'string' ? decodedBlob.reasoning : undefined,
                     // v1.1: surface pin_status verbatim for downstream (recall display +
                     // export). Absent ⇒ undefined (receivers treat as "unpinned").
-                    pin_status: typeof obj.pin_status === 'string' ? obj.pin_status : undefined,
+                    pin_status: typeof decodedBlob.pin_status === 'string' ? decodedBlob.pin_status : undefined,
                     importance: importance / 10,
-                    created_at: typeof obj.created_at === 'string' ? obj.created_at : '',
-                    schema_version: obj.schema_version,
+                    created_at: typeof decodedBlob.created_at === 'string' ? decodedBlob.created_at : '',
+                    schema_version: decodedBlob.schema_version,
                 },
             };
         }
         // New canonical Claim format: short keys
-        if (typeof obj.t === 'string' && typeof obj.c === 'string') {
-            const importance = typeof obj.i === 'number' ? Math.max(1, Math.min(10, Math.round(obj.i))) : 5;
+        if (typeof decodedBlob.t === 'string' && typeof decodedBlob.c === 'string') {
+            const importance = typeof decodedBlob.i === 'number' ? Math.max(1, Math.min(10, Math.round(decodedBlob.i))) : 5;
             return {
-                text: obj.t,
+                text: decodedBlob.t,
                 importance,
-                category: obj.c,
+                category: decodedBlob.c,
                 metadata: {
-                    type: obj.c,
+                    type: decodedBlob.c,
                     importance: importance / 10,
-                    source: typeof obj.sa === 'string' ? obj.sa : 'auto-extraction',
-                    created_at: typeof obj.ea === 'string' ? obj.ea : '',
+                    source: typeof decodedBlob.sa === 'string' ? decodedBlob.sa : 'auto-extraction',
+                    created_at: typeof decodedBlob.ea === 'string' ? decodedBlob.ea : '',
                 },
             };
         }
         // Legacy plugin {text, metadata: {importance: 0-1}} format
-        if (typeof obj.text === 'string') {
-            const meta = obj.metadata ?? {};
+        if (typeof decodedBlob.text === 'string') {
+            const meta = decodedBlob.metadata ?? {};
             const impFloat = typeof meta.importance === 'number' ? meta.importance : 0.5;
             const importance = Math.max(1, Math.min(10, Math.round(impFloat * 10)));
             return {
-                text: obj.text,
+                text: decodedBlob.text,
                 importance,
                 category: typeof meta.type === 'string' ? meta.type : 'fact',
                 metadata: meta,

package/dist/extraction/consolidation.js

@@ -0,0 +1,170 @@
+/**
+ * TotalReclaw Plugin - Memory Consolidation & Near-Duplicate Detection
+ *
+ * Provides cross-session / cross-vault deduplication of stored facts using
+ * cosine similarity on their embeddings. Unlike semantic-dedup.ts (which
+ * handles within-batch dedup at threshold 0.9), this module handles:
+ *
+ *   1. Store-time dedup — before writing a new fact, check whether a
+ *      near-duplicate already exists in the vault (findNearDuplicate).
+ *   2. Supersede logic — when a near-duplicate is found, decide whether
+ *      the new fact should replace or be skipped (shouldSupersede).
+ *   3. Bulk consolidation — cluster all facts in the vault and identify
+ *      groups of near-duplicates for cleanup (clusterFacts).
+ *
+ * Delegates core computation to `@totalreclaw/core` Rust WASM module:
+ * `findNearDuplicate`, `shouldSupersede`, and `clusterFacts` all call the
+ * corresponding core functions directly.
+ *
+ * Threshold helpers remain local; their env reads are centralized in
+ * entry.ts (env-reading seam, Task 1.3 of the OpenClaw native
+ * integration plan, 2026-06-21).
+ */
+import { createRequire } from 'node:module';
+import { envNumber } from '../entry.js';
+// ---------------------------------------------------------------------------
+// Lazy-load WASM core (mirrors claims-helper.ts / contradiction-sync.ts
+// pattern — plays nicely under both the OpenClaw runtime (CJS-ish tsx) and
+// bare Node ESM used by tests).
+// ---------------------------------------------------------------------------
+const requireWasm = createRequire(import.meta.url);
+let _wasm = null;
+function getWasm() {
+    if (!_wasm)
+        _wasm = requireWasm('@totalreclaw/core');
+    return _wasm;
+}
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+/**
+ * Get the cosine similarity threshold for store-time dedup.
+ *
+ * Configurable via TOTALRECLAW_STORE_DEDUP_THRESHOLD env var.
+ * Must be a number in [0, 1]. Falls back to 0.85 if invalid or unset.
+ */
+export function getStoreDedupThreshold() {
+    return envNumber('TOTALRECLAW_STORE_DEDUP_THRESHOLD', 0.85, { min: 0, max: 1 });
+}
+/**
+ * Get the cosine similarity threshold for bulk consolidation clustering.
+ *
+ * Configurable via TOTALRECLAW_CONSOLIDATION_THRESHOLD env var.
+ * Must be a number in [0, 1]. Falls back to 0.88 if invalid or unset.
+ */
+export function getConsolidationThreshold() {
+    return envNumber('TOTALRECLAW_CONSOLIDATION_THRESHOLD', 0.88, { min: 0, max: 1 });
+}
+/** Maximum candidates to compare against during store-time dedup. */
+export const STORE_DEDUP_MAX_CANDIDATES = 200;
+// ---------------------------------------------------------------------------
+// Store-time dedup
+// ---------------------------------------------------------------------------
+/**
+ * Find the best near-duplicate match for a new fact among existing candidates.
+ *
+ * Compares the new fact's embedding against all candidates using cosine
+ * similarity. Returns the candidate with the highest similarity above the
+ * threshold, or null if no match is found.
+ *
+ * Candidates without embeddings are skipped (fail-safe).
+ *
+ * @param newFactEmbedding - Embedding vector for the new fact
+ * @param candidates       - Existing facts to compare against
+ * @param threshold        - Cosine similarity threshold (e.g. 0.85)
+ * @returns                - Best match above threshold, or null
+ */
+export function findNearDuplicate(newFactEmbedding, candidates, threshold) {
+    const wasm = getWasm();
+    const existing = candidates
+        .filter((c) => c.embedding && c.embedding.length > 0)
+        .map((c) => ({ id: c.id, embedding: c.embedding }));
+    if (existing.length === 0)
+        return null;
+    const bestMatchJs = wasm.findBestNearDuplicate(JSON.stringify(newFactEmbedding), JSON.stringify(existing), threshold);
+    if (bestMatchJs == null)
+        return null;
+    const bestMatch = typeof bestMatchJs === 'string' ? JSON.parse(bestMatchJs) : bestMatchJs;
+    const matched = candidates.find((c) => c.id === bestMatch.fact_id);
+    if (!matched)
+        return null;
+    return { existingFact: matched, similarity: bestMatch.similarity };
+}
+// ---------------------------------------------------------------------------
+// Supersede logic
+// ---------------------------------------------------------------------------
+/**
+ * Decide whether a new fact should supersede an existing near-duplicate.
+ *
+ * - Higher importance wins.
+ * - Equal importance: new fact supersedes (newer is preferred).
+ *
+ * Delegates to `@totalreclaw/core` WASM `shouldSupersede`.
+ *
+ * @param newImportance - Importance score of the new fact
+ * @param existingFact  - The existing near-duplicate candidate
+ * @returns             - 'supersede' if new fact should replace, 'skip' otherwise
+ */
+export function shouldSupersede(newImportance, existingFact) {
+    const wasm = getWasm();
+    return wasm.shouldSupersede(newImportance, existingFact.importance) ? 'supersede' : 'skip';
+}
+// ---------------------------------------------------------------------------
+// Bulk consolidation
+// ---------------------------------------------------------------------------
+/**
+ * Cluster facts by semantic similarity using greedy single-pass clustering.
+ *
+ * Delegates to `@totalreclaw/core` WASM `clusterFacts` which performs the
+ * same greedy single-pass algorithm and representative selection. The WASM
+ * function returns ID-only clusters; this wrapper maps IDs back to full
+ * `DecryptedCandidate` objects for callers.
+ *
+ * Only returns clusters that have duplicates (i.e. more than one member).
+ * Facts without embeddings are not clustered.
+ *
+ * @param facts     - All facts to cluster
+ * @param threshold - Cosine similarity threshold (e.g. 0.88)
+ * @returns         - Clusters with duplicates (representative + duplicates)
+ */
+export function clusterFacts(facts, threshold) {
+    const wasm = getWasm();
+    // Build ConsolidationCandidate JSON for WASM (snake_case fields).
+    const wasmCandidates = facts
+        .filter((f) => f.embedding && f.embedding.length > 0)
+        .map((f) => ({
+        id: f.id,
+        text: f.text,
+        embedding: f.embedding,
+        importance: f.importance,
+        decay_score: f.decayScore,
+        created_at: f.createdAt,
+        version: f.version,
+    }));
+    if (wasmCandidates.length === 0)
+        return [];
+    const clustersJs = wasm.clusterFacts(JSON.stringify(wasmCandidates), threshold);
+    // WASM returns a JSON string: [{ representative: string, duplicates: string[] }]
+    const wasmClusters = typeof clustersJs === 'string' ? JSON.parse(clustersJs) : clustersJs;
+    // Build a lookup map for fast ID -> DecryptedCandidate resolution.
+    const byId = new Map();
+    for (const f of facts)
+        byId.set(f.id, f);
+    // Map ID-only clusters back to full DecryptedCandidate objects.
+    // Filter out singleton clusters (no duplicates) to match the pre-WASM
+    // plugin contract — callers rely on `clusters.length === 0` when nothing
+    // duplicates anything.
+    const clusters = [];
+    for (const wc of wasmClusters) {
+        const rep = byId.get(wc.representative);
+        if (!rep)
+            continue;
+        const dups = wc.duplicates
+            .map((id) => byId.get(id))
+            .filter((d) => d !== undefined);
+        if (dups.length > 0) {
+            clusters.push({ representative: rep, duplicates: dups });
+        }
+    }
+    return clusters;
+}

package/dist/{extractor.js → extraction/extractor.js}

@@ -4,7 +4,7 @@
  * Uses LLM calls to extract atomic facts from conversation messages.
  * Matches the extraction prompts described in SKILL.md.
  */
-import { chatCompletion, resolveLLMConfig } from './llm-client.js';
+import { chatCompletion, resolveLLMConfig } from '../llm/llm-client.js';
 // ---------------------------------------------------------------------------
 // Memory Taxonomy v1 — the 6 canonical memory types. Single source of truth.
 //
@@ -461,7 +461,7 @@ export function parseFactsResponseForCompaction(response, logger) {
         }
     }
     if (recoveryUsed === 'bracket-scan') {
-        logger?.info?.(`parseFactsResponseForCompaction: recovered JSON via bracket-scan fallback`);
+        logger?.debug?.(`parseFactsResponseForCompaction: recovered JSON via bracket-scan fallback`);
     }
     if (!parsed || typeof parsed !== 'object') {
         logger?.warn?.(`parseFactsResponseForCompaction: could not parse LLM output as JSON object. Preview: ${JSON.stringify(originalPreview)}`);
@@ -514,7 +514,7 @@ export function parseFactsResponseForCompaction(response, logger) {
             if (valid.length > 0)
                 entities = valid;
         }
-        const result = {
+        const extractedFact = {
             text: String(f.text).slice(0, 512),
             type,
             source,
@@ -526,8 +526,8 @@ export function parseFactsResponseForCompaction(response, logger) {
             confidence: normalizeConfidence(f.confidence),
         };
         if (entities)
-            result.entities = entities;
-        return result;
+            extractedFact.entities = entities;
+        return extractedFact;
     })
         // Reject illegal type:summary + source:user
         .filter((f) => !(f.type === 'summary' && f.source === 'user'))
@@ -601,7 +601,7 @@ export async function extractFactsForCompaction(rawMessages, existingMemories, l
         logger?.info?.('extractFactsForCompaction: chatCompletion returned null/empty response');
         return [];
     }
-    logger?.info?.(`extractFactsForCompaction: LLM returned ${response.length} chars; handing to parseFactsResponseForCompaction`);
+    logger?.debug?.(`extractFactsForCompaction: LLM returned ${response.length} chars; handing to parseFactsResponseForCompaction`);
     let facts = parseFactsResponseForCompaction(response, logger);
     // v1 provenance filter (tag-don't-drop). Uses importance >= 5 floor because
     // the filter's own floor is 5 in lax mode, matching compaction semantics.
@@ -617,7 +617,7 @@ export async function extractFactsForCompaction(rawMessages, existingMemories, l
             const oldImportance = f.importance;
             const effectiveBump = f.importance >= 8 ? Math.min(bump, 1) : bump;
             f.importance = Math.min(10, f.importance + effectiveBump);
-            logger?.info?.(`extractFactsForCompaction: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`);
+            logger?.debug?.(`extractFactsForCompaction: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`);
         }
     }
     return facts;
@@ -1020,7 +1020,7 @@ export function parseMergedResponseV1(response, logger) {
         }
     }
     if (recoveryUsed === 'bracket-scan') {
-        logger?.info?.(`parseFactsResponse: recovered JSON via bracket-scan fallback`);
+        logger?.debug?.(`parseFactsResponse: recovered JSON via bracket-scan fallback`);
     }
     if (!parsed || typeof parsed !== 'object') {
         logger?.warn?.(`parseFactsResponse: could not parse LLM output as JSON. Preview: ${JSON.stringify(originalPreview)}`);
@@ -1030,25 +1030,25 @@ export function parseMergedResponseV1(response, logger) {
     // a bare JSON array of fact objects (legacy / test fixture shape). The
     // bare array is wrapped as { topics: [], facts: [...] } so the downstream
     // logic stays uniform. A single fact object (no wrapper) is also wrapped.
-    let obj;
+    let wrapper;
     if (Array.isArray(parsed)) {
-        obj = { topics: [], facts: parsed };
+        wrapper = { topics: [], facts: parsed };
     }
     else if (typeof parsed.facts === 'undefined' &&
         typeof parsed.text === 'string') {
         // Single fact object, not a merged wrapper.
-        obj = { topics: [], facts: [parsed] };
+        wrapper = { topics: [], facts: [parsed] };
     }
     else {
-        obj = parsed;
+        wrapper = parsed;
     }
-    const rawTopics = obj.topics;
+    const rawTopics = wrapper.topics;
     const topics = Array.isArray(rawTopics)
         ? rawTopics
             .filter((t) => typeof t === 'string' && t.length > 0)
             .slice(0, 3)
         : [];
-    const rawFacts = obj.facts;
+    const rawFacts = wrapper.facts;
     if (!Array.isArray(rawFacts))
         return { topics, facts: [] };
     const validActions = ['ADD', 'UPDATE', 'DELETE', 'NOOP'];
@@ -1334,10 +1334,10 @@ export async function extractFacts(rawMessages, mode, existingMemories, profileC
         logger?.info?.('extractFacts: chatCompletion returned null/empty response');
         return [];
     }
-    logger?.info?.(`extractFacts: LLM returned ${response.length} chars; parsing merged response`);
+    logger?.debug?.(`extractFacts: LLM returned ${response.length} chars; parsing merged response`);
     const { topics, facts: rawFacts } = parseMergedResponseV1(response, logger);
     if (topics.length > 0) {
-        logger?.info?.(`extractFacts: topics = ${JSON.stringify(topics)}`);
+        logger?.debug?.(`extractFacts: topics = ${JSON.stringify(topics)}`);
     }
     // Provenance filter (tag-don't-drop)
     let facts = applyProvenanceFilterLax(rawFacts, conversationText);
@@ -1352,7 +1352,7 @@ export async function extractFacts(rawMessages, mode, existingMemories, profileC
             const oldImportance = f.importance;
             const effectiveBump = f.importance >= 8 ? Math.min(bump, 1) : bump;
             f.importance = Math.min(10, f.importance + effectiveBump);
-            logger?.info?.(`extractFacts: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`);
+            logger?.debug?.(`extractFacts: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`);
         }
     }
     return facts;

package/dist/extraction/importance-filter.js

@@ -0,0 +1,38 @@
+// ---------------------------------------------------------------------------
+// Importance filter for auto-extraction. Extracted from index.ts.
+// Pure over its inputs (threshold derives from CONFIG); no plugin session state.
+// ---------------------------------------------------------------------------
+import { CONFIG } from '../config.js';
+const MIN_IMPORTANCE_THRESHOLD = CONFIG.minImportance;
+/**
+ * Filter extracted facts by importance threshold.
+ * Facts with importance < MIN_IMPORTANCE_THRESHOLD are dropped.
+ * Facts with missing/undefined importance are treated as importance=5 (kept).
+ */
+export function filterByImportance(facts, logger) {
+    const kept = [];
+    let dropped = 0;
+    for (const fact of facts) {
+        const importance = fact.importance ?? 5;
+        if (importance >= MIN_IMPORTANCE_THRESHOLD) {
+            kept.push(fact);
+        }
+        else {
+            dropped++;
+        }
+    }
+    // Phase 2.2.5: always log the filter outcome so the agent_end path can
+    // distinguish "LLM returned 0 facts" from "LLM returned N facts all dropped
+    // below threshold" from "LLM returned N facts, all kept". Prior to 2.2.5
+    // this only logged on drops, which made empty-input invisible.
+    if (facts.length === 0) {
+        logger.info('Importance filter: input=0 (nothing to filter)');
+    }
+    else if (dropped > 0) {
+        logger.info(`Importance filter: dropped ${dropped}/${facts.length} facts below threshold ${MIN_IMPORTANCE_THRESHOLD}`);
+    }
+    else {
+        logger.info(`Importance filter: kept all ${facts.length} facts (threshold ${MIN_IMPORTANCE_THRESHOLD})`);
+    }
+    return { kept, dropped };
+}

package/dist/{semantic-dedup.js → extraction/semantic-dedup.js}

@@ -10,8 +10,8 @@
  * cosineSimilarity and extractor for the ExtractedFact type) so it can
  * be tested without pulling in the full plugin dependency graph.
  */
-import { cosineSimilarity } from './reranker.js';
-import { envNumber } from './entry.js';
+import { cosineSimilarity } from '../embedding/reranker.js';
+import { envNumber } from '../entry.js';
 // ---------------------------------------------------------------------------
 // Configuration
 // ---------------------------------------------------------------------------

package/dist/{batch-gate.js → import/batch-gate.js}

@@ -23,7 +23,7 @@
  * Env read is centralized in entry.ts (env-reading seam, Task 1.3 of the
  * OpenClaw native integration plan, 2026-06-21).
  */
-import { isGnosisBatchEnabledAtBoot } from './entry.js';
+import { isGnosisBatchEnabledAtBoot } from '../entry.js';
 const GNOSIS_CHAIN_ID = 100;
 export function shouldBatchOnChain(chainId) {
     if (!isGnosisBatchEnabledAtBoot())