@totalreclaw/totalreclaw 3.3.12 → 3.3.13-rc.1

package/{claims-helper.ts → extraction/claims-helper.ts}

@@ -16,21 +16,18 @@ import type {
   ExtractedFact,
   MemoryType,
   MemoryTypeV0,
-  MemoryTypeV1,
   MemoryScope,
   MemorySource,
   MemoryVolatility,
 } from './extractor.js';
 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 { 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).
@@ -163,7 +160,7 @@ export const V1_SCHEMA_VERSION = '1.0' as const;
 export type PinStatus = 'pinned' | 'unpinned';
 
 export interface BuildClaimV1Input {
-  /** The extracted fact in v1 shape. Must have `type` as a MemoryTypeV1 token. */
+  /** The extracted fact in v1 shape. Must have `type` as a MemoryType token. */
   fact: ExtractedFact;
   /** Final importance after any store-time dedup adjustment. 1-10. */
   importance: number;
@@ -453,7 +450,7 @@ export function isV1Blob(decrypted: string): boolean {
  */
 export interface V1BlobReadResult {
   text: string;
-  type: MemoryTypeV1;
+  type: MemoryType;
   source: MemorySource;
   scope: MemoryScope;
   volatility: MemoryVolatility;
@@ -481,34 +478,34 @@ export interface V1BlobReadResult {
 
 export function readV1Blob(decrypted: string): V1BlobReadResult | null {
   try {
-    const obj = JSON.parse(decrypted) as Record<string, unknown>;
-    if (typeof obj.schema_version !== 'string' || !obj.schema_version.startsWith('1.')) {
+    const decodedBlob = JSON.parse(decrypted) as Record<string, unknown>;
+    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: MemoryTypeV1 = isValidMemoryTypeV1(rawType) ? rawType : 'claim';
+    const text = typeof decodedBlob.text === 'string' ? decodedBlob.text : '';
+    const rawType = typeof decodedBlob.type === 'string' ? decodedBlob.type : 'claim';
+    const type: MemoryType = isValidMemoryType(rawType) ? rawType : 'claim';
 
-    const rawSource = typeof obj.source === 'string' ? obj.source : 'user-inferred';
+    const rawSource = typeof decodedBlob.source === 'string' ? decodedBlob.source : 'user-inferred';
     const source: MemorySource = (VALID_MEMORY_SOURCES as readonly string[]).includes(rawSource)
       ? (rawSource as MemorySource)
       : 'user-inferred';
 
-    const rawScope = typeof obj.scope === 'string' ? obj.scope : 'unspecified';
+    const rawScope = typeof decodedBlob.scope === 'string' ? decodedBlob.scope : 'unspecified';
     const scope: MemoryScope = (VALID_MEMORY_SCOPES as readonly string[]).includes(rawScope)
       ? (rawScope as MemoryScope)
       : 'unspecified';
 
-    const rawVolatility = typeof obj.volatility === 'string' ? obj.volatility : 'updatable';
+    const rawVolatility = typeof decodedBlob.volatility === 'string' ? decodedBlob.volatility : 'updatable';
     const volatility: MemoryVolatility = (VALID_MEMORY_VOLATILITIES as readonly string[]).includes(rawVolatility)
       ? (rawVolatility as MemoryVolatility)
       : '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: V1BlobReadResult = {
@@ -519,14 +516,14 @@ export function readV1Blob(decrypted: string): V1BlobReadResult | null {
       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 as unknown[]).filter(
+    if (Array.isArray(decodedBlob.entities)) {
+      result.entities = (decodedBlob.entities as unknown[]).filter(
         (e): e is { name: string; type: string; role?: string } =>
           !!e &&
           typeof e === 'object' &&
@@ -534,11 +531,11 @@ export function readV1Blob(decrypted: string): V1BlobReadResult | null {
           typeof (e as { type?: unknown }).type === 'string',
       ) as Array<{ name: string; type: string; role?: 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;
       }
@@ -546,8 +543,8 @@ export function readV1Blob(decrypted: string): V1BlobReadResult | null {
     // 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;
@@ -556,11 +553,6 @@ export function readV1Blob(decrypted: string): V1BlobReadResult | 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
 //
@@ -662,60 +654,60 @@ export interface BlobReadResult {
 
 export function readClaimFromBlob(decryptedJson: string): BlobReadResult {
   try {
-    const obj = JSON.parse(decryptedJson) as Record<string, unknown>;
+    const decodedBlob = JSON.parse(decryptedJson) as Record<string, unknown>;
 
     // 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.')
+      typeof decodedBlob.text === 'string' &&
+      typeof decodedBlob.type === 'string' &&
+      typeof decodedBlob.schema_version === 'string' &&
+      decodedBlob.schema_version.startsWith('1.')
     ) {
-      const importance = typeof obj.importance === 'number'
-        ? Math.max(1, Math.min(10, Math.round(obj.importance)))
+      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 as MemoryTypeV1),
+        category: mapTypeToCategory(decodedBlob.type as MemoryType),
         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 as Record<string, unknown>) ?? {};
+    if (typeof decodedBlob.text === 'string') {
+      const meta = (decodedBlob.metadata as Record<string, unknown>) ?? {};
       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/{consolidation.ts → extraction/consolidation.ts}

@@ -12,11 +12,9 @@
  *   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 where
- * bindings are available. `shouldSupersede` uses the core directly.
- * `findNearDuplicate` and `clusterFacts` use the core's `findBestNearDuplicate`
- * and `clusterFacts` WASM functions when available, falling back to local
- * implementations that use WASM-backed `cosineSimilarity`.
+ * 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
@@ -24,8 +22,7 @@
  */
 
 import { createRequire } from 'node:module';
-import { cosineSimilarity } from './reranker.js';
-import { envNumber } from './entry.js';
+import { envNumber } from '../entry.js';
 
 // ---------------------------------------------------------------------------
 // Lazy-load WASM core (mirrors claims-helper.ts / contradiction-sync.ts
@@ -118,48 +115,27 @@ export function findNearDuplicate(
 ): NearDuplicateMatch | null {
   const wasm = getWasm();
 
-  // Use core's findBestNearDuplicate if available (added in core >=1.5.0;
-  // guaranteed present in core >=2.0.0 which this plugin depends on).
-  if (typeof (wasm as any).findBestNearDuplicate === 'function') {
-    const existing = candidates
-      .filter((c) => c.embedding && c.embedding.length > 0)
-      .map((c) => ({ id: c.id, embedding: c.embedding! }));
+  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;
+  if (existing.length === 0) return null;
 
-    const resultJs = (wasm as any).findBestNearDuplicate(
-      JSON.stringify(newFactEmbedding),
-      JSON.stringify(existing),
-      threshold,
-    );
+  const bestMatchJs = (wasm as any).findBestNearDuplicate(
+    JSON.stringify(newFactEmbedding),
+    JSON.stringify(existing),
+    threshold,
+  );
 
-    if (resultJs == null) return null;
+  if (bestMatchJs == null) return null;
 
-    const result: { fact_id: string; similarity: number } =
-      typeof resultJs === 'string' ? JSON.parse(resultJs) : resultJs;
+  const bestMatch: { fact_id: string; similarity: number } =
+    typeof bestMatchJs === 'string' ? JSON.parse(bestMatchJs) : bestMatchJs;
 
-    const matched = candidates.find((c) => c.id === result.fact_id);
-    if (!matched) return null;
+  const matched = candidates.find((c) => c.id === bestMatch.fact_id);
+  if (!matched) return null;
 
-    return { existingFact: matched, similarity: result.similarity };
-  }
-
-  // Fallback: local loop using WASM-backed cosineSimilarity. Defensive only
-  // — core >=2.0.0 always exposes findBestNearDuplicate.
-  let bestMatch: NearDuplicateMatch | null = null;
-
-  for (const candidate of candidates) {
-    if (!candidate.embedding || candidate.embedding.length === 0) continue;
-
-    const similarity = cosineSimilarity(newFactEmbedding, candidate.embedding);
-    if (similarity >= threshold) {
-      if (!bestMatch || similarity > bestMatch.similarity) {
-        bestMatch = { existingFact: candidate, similarity };
-      }
-    }
-  }
-
-  return bestMatch;
+  return { existingFact: matched, similarity: bestMatch.similarity };
 }
 
 // ---------------------------------------------------------------------------
@@ -211,118 +187,51 @@ export function clusterFacts(
 ): ConsolidationCluster[] {
   const wasm = getWasm();
 
-  // Use core's clusterFacts if available (added in core >=1.5.0;
-  // guaranteed present in core >=2.0.0 which this plugin depends on).
-  if (typeof (wasm as any).clusterFacts === 'function') {
-    // 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 resultJs = (wasm as any).clusterFacts(
-      JSON.stringify(wasmCandidates),
-      threshold,
-    );
-
-    // WASM returns a JSON string: [{ representative: string, duplicates: string[] }]
-    const wasmClusters: { representative: string; duplicates: string[] }[] =
-      typeof resultJs === 'string' ? JSON.parse(resultJs) : resultJs;
-
-    // Build a lookup map for fast ID -> DecryptedCandidate resolution.
-    const byId = new Map<string, DecryptedCandidate>();
-    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 result: ConsolidationCluster[] = [];
-    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 is DecryptedCandidate => d !== undefined);
-
-      if (dups.length > 0) {
-        result.push({ representative: rep, duplicates: dups });
-      }
+  // 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 as any).clusterFacts(
+    JSON.stringify(wasmCandidates),
+    threshold,
+  );
+
+  // WASM returns a JSON string: [{ representative: string, duplicates: string[] }]
+  const wasmClusters: { representative: string; duplicates: string[] }[] =
+    typeof clustersJs === 'string' ? JSON.parse(clustersJs) : clustersJs;
+
+  // Build a lookup map for fast ID -> DecryptedCandidate resolution.
+  const byId = new Map<string, DecryptedCandidate>();
+  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: ConsolidationCluster[] = [];
+  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 is DecryptedCandidate => d !== undefined);
+
+    if (dups.length > 0) {
+      clusters.push({ representative: rep, duplicates: dups });
     }
-
-    return result;
   }
 
-  // Fallback: local greedy single-pass clustering using WASM-backed
-  // cosineSimilarity. Defensive only — core >=2.0.0 always exposes clusterFacts.
-  const clusters: { members: DecryptedCandidate[] }[] = [];
-
-  for (const fact of facts) {
-    if (!fact.embedding || fact.embedding.length === 0) continue;
-
-    let assigned = false;
-    for (const cluster of clusters) {
-      const seed = cluster.members[0];
-      if (!seed.embedding) continue;
-
-      const similarity = cosineSimilarity(fact.embedding, seed.embedding);
-      if (similarity >= threshold) {
-        cluster.members.push(fact);
-        assigned = true;
-        break;
-      }
-    }
-
-    if (!assigned) {
-      clusters.push({ members: [fact] });
-    }
-  }
-
-  const result: ConsolidationCluster[] = [];
-  for (const cluster of clusters) {
-    if (cluster.members.length < 2) continue;
-
-    const representative = pickRepresentative(cluster.members);
-    const duplicates = cluster.members.filter((m) => m !== representative);
-    result.push({ representative, duplicates });
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Local helpers (used only in fallback paths)
-// ---------------------------------------------------------------------------
-
-/**
- * Pick the best representative from a group of near-duplicate facts.
- *
- * Tiebreak order:
- *   1. Highest decayScore
- *   2. Most recent (highest createdAt)
- *   3. Longest text
- */
-function pickRepresentative(facts: DecryptedCandidate[]): DecryptedCandidate {
-  let best = facts[0];
-  for (let i = 1; i < facts.length; i++) {
-    const f = facts[i];
-    if (
-      f.decayScore > best.decayScore ||
-      (f.decayScore === best.decayScore && f.createdAt > best.createdAt) ||
-      (f.decayScore === best.decayScore && f.createdAt === best.createdAt && f.text.length > best.text.length)
-    ) {
-      best = f;
-    }
-  }
-  return best;
+  return clusters;
 }

package/{extractor.ts → extraction/extractor.ts}

@@ -5,7 +5,7 @@
  * Matches the extraction prompts described in SKILL.md.
  */
 
-import { chatCompletion, resolveLLMConfig } from './llm-client.js';
+import { chatCompletion, resolveLLMConfig } from '../llm/llm-client.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -348,6 +348,7 @@ export function normalizeConfidence(raw: unknown): number {
 export interface ExtractorLogger {
   info?: (msg: string) => void;
   warn?: (msg: string) => void;
+  debug?: (msg: string) => void;
 }
 
 
@@ -617,7 +618,7 @@ export function parseFactsResponseForCompaction(
     }
   }
   if (recoveryUsed === 'bracket-scan') {
-    logger?.info?.(
+    logger?.debug?.(
       `parseFactsResponseForCompaction: recovered JSON via bracket-scan fallback`,
     );
   }
@@ -687,7 +688,7 @@ export function parseFactsResponseForCompaction(
         if (valid.length > 0) entities = valid;
       }
 
-      const result: ExtractedFact = {
+      const extractedFact: ExtractedFact = {
         text: String(f.text).slice(0, 512),
         type,
         source,
@@ -698,8 +699,8 @@ export function parseFactsResponseForCompaction(
         existingFactId: typeof f.existingFactId === 'string' ? f.existingFactId : undefined,
         confidence: normalizeConfidence(f.confidence),
       };
-      if (entities) result.entities = entities;
-      return result;
+      if (entities) extractedFact.entities = entities;
+      return extractedFact;
     })
     // Reject illegal type:summary + source:user
     .filter((f) => !(f.type === 'summary' && f.source === 'user'))
@@ -789,7 +790,7 @@ export async function extractFactsForCompaction(
     return [];
   }
 
-  logger?.info?.(
+  logger?.debug?.(
     `extractFactsForCompaction: LLM returned ${response.length} chars; handing to parseFactsResponseForCompaction`,
   );
   let facts = parseFactsResponseForCompaction(response, logger);
@@ -810,7 +811,7 @@ export async function extractFactsForCompaction(
       const oldImportance = f.importance;
       const effectiveBump = f.importance >= 8 ? Math.min(bump, 1) : bump;
       f.importance = Math.min(10, f.importance + effectiveBump);
-      logger?.info?.(
+      logger?.debug?.(
         `extractFactsForCompaction: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`,
       );
     }
@@ -1251,7 +1252,7 @@ export function parseMergedResponseV1(
     }
   }
   if (recoveryUsed === 'bracket-scan') {
-    logger?.info?.(
+    logger?.debug?.(
       `parseFactsResponse: recovered JSON via bracket-scan fallback`,
     );
   }
@@ -1267,27 +1268,27 @@ export function parseMergedResponseV1(
   // 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: Record<string, unknown>;
+  let wrapper: Record<string, unknown>;
   if (Array.isArray(parsed)) {
-    obj = { topics: [], facts: parsed };
+    wrapper = { topics: [], facts: parsed };
   } else if (
     typeof (parsed as Record<string, unknown>).facts === 'undefined' &&
     typeof (parsed as Record<string, unknown>).text === 'string'
   ) {
     // Single fact object, not a merged wrapper.
-    obj = { topics: [], facts: [parsed] };
+    wrapper = { topics: [], facts: [parsed] };
   } else {
-    obj = parsed as Record<string, unknown>;
+    wrapper = parsed as Record<string, unknown>;
   }
 
-  const rawTopics = obj.topics;
+  const rawTopics = wrapper.topics;
   const topics = Array.isArray(rawTopics)
     ? (rawTopics as unknown[])
         .filter((t): t is string => 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: ExtractionAction[] = ['ADD', 'UPDATE', 'DELETE', 'NOOP'];
@@ -1625,12 +1626,12 @@ export async function extractFacts(
     return [];
   }
 
-  logger?.info?.(
+  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)
@@ -1649,7 +1650,7 @@ export async function extractFacts(
       const oldImportance = f.importance;
       const effectiveBump = f.importance >= 8 ? Math.min(bump, 1) : bump;
       f.importance = Math.min(10, f.importance + effectiveBump);
-      logger?.info?.(
+      logger?.debug?.(
         `extractFacts: lexical bump +${bump} for "${f.text.slice(0, 60)}..." (${oldImportance} → ${f.importance})`,
       );
     }

package/extraction/importance-filter.ts

@@ -0,0 +1,50 @@
+// ---------------------------------------------------------------------------
+// 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';
+import type { ExtractedFact } from './extractor.js';
+import type { OpenClawPluginApi } from '../runtime/types.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: ExtractedFact[],
+  logger: OpenClawPluginApi['logger'],
+): { kept: ExtractedFact[]; dropped: number } {
+  const kept: ExtractedFact[] = [];
+  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 };
+}