@voidwire/lore 1.6.0 → 1.6.2

package/cli.ts

@@ -59,6 +59,7 @@ import {
   type ObservationSubtype,
   type ObservationConfidence,
   type PurgeableSource,
+  type ContradictionDecision,
 } from "./index";
 import { isValidLoreType, LORE_TYPES } from "./lib/types";
 import { runIndexer } from "./lib/indexer";
@@ -164,6 +165,26 @@ function fail(error: string, code: number = 1): never {
   process.exit(code);
 }
 
+/**
+ * Log contradiction decisions to stderr (CLI context).
+ * Only logs non-ADD actions — ADD is the default/expected path.
+ */
+function logContradictionDecisions(decisions: ContradictionDecision[]): void {
+  for (const d of decisions) {
+    if (d.action === "NOOP") {
+      console.error(
+        `[contradiction] NOOP: skipped as redundant (topic: ${d.topic})`,
+      );
+    } else if (d.action === "DELETE+ADD") {
+      console.error(
+        `[contradiction] DELETE+ADD: replaced rowid ${d.deleteRowid} (topic: ${d.topic})`,
+      );
+    } else if (d.error) {
+      console.error(`[contradiction] ADD (fallback): ${d.error}`);
+    }
+  }
+}
+
 // ============================================================================
 // Search Command
 // ============================================================================
@@ -783,8 +804,9 @@ async function handleCaptureTask(args: string[]): Promise<void> {
 
   if (result.success && result.event) {
     try {
-      await indexAndEmbed([result.event]);
+      const decisions = await indexAndEmbed([result.event]);
       output(result);
+      logContradictionDecisions(decisions);
       console.error("✅ Task logged and indexed");
       process.exit(0);
     } catch (error) {
@@ -818,8 +840,9 @@ async function handleCaptureKnowledge(args: string[]): Promise<void> {
 
   if (result.success && result.event) {
     try {
-      await indexAndEmbed([result.event]);
+      const decisions = await indexAndEmbed([result.event]);
       output(result);
+      logContradictionDecisions(decisions);
       console.error("✅ Knowledge logged and indexed");
       process.exit(0);
     } catch (error) {
@@ -851,8 +874,9 @@ async function handleCaptureNote(args: string[]): Promise<void> {
 
   if (result.success && result.event) {
     try {
-      await indexAndEmbed([result.event]);
+      const decisions = await indexAndEmbed([result.event]);
       output(result);
+      logContradictionDecisions(decisions);
       console.error("✅ Note logged and indexed");
       process.exit(0);
     } catch (error) {
@@ -887,8 +911,9 @@ async function handleCaptureTeaching(args: string[]): Promise<void> {
 
   if (result.success && result.event) {
     try {
-      await indexAndEmbed([result.event]);
+      const decisions = await indexAndEmbed([result.event]);
       output(result);
+      logContradictionDecisions(decisions);
       console.error("✅ Teaching logged and indexed");
       process.exit(0);
     } catch (error) {
@@ -924,8 +949,9 @@ async function handleCaptureObservation(args: string[]): Promise<void> {
 
   if (result.success && result.event) {
     try {
-      await indexAndEmbed([result.event]);
+      const decisions = await indexAndEmbed([result.event]);
       output(result);
+      logContradictionDecisions(decisions);
       console.error("✅ Observation logged and indexed");
       process.exit(0);
     } catch (error) {

package/index.ts

@@ -102,6 +102,7 @@ export { LoreType, LORE_TYPES, isValidLoreType } from "./lib/types";
 
 // Real-time indexing
 export { indexAndEmbed } from "./lib/realtime";
+export { type ContradictionDecision } from "./lib/contradiction";
 
 // Purge
 export {

package/lib/contradiction.ts

@@ -27,6 +27,15 @@ export interface ContradictionResult {
   deleteRowid?: number;
 }
 
+/** Decision record returned to callers for logging */
+export interface ContradictionDecision {
+  action: ContradictionAction;
+  topic: string;
+  source: string;
+  deleteRowid?: number;
+  error?: string;
+}
+
 // ─── Constants ──────────────────────────────────────────────────────────────
 
 const MLX_URL = "http://localhost:8080/v1/chat/completions";
@@ -133,9 +142,6 @@ Otherwise reply: ADD or NOOP`;
     });
 
     if (!resp.ok) {
-      console.error(
-        `[contradiction] MLX returned ${resp.status} — defaulting to ADD`,
-      );
       return { action: "ADD" };
     }
 
@@ -145,12 +151,8 @@ Otherwise reply: ADD or NOOP`;
 
     const raw = json.choices?.[0]?.message?.content?.trim() || "";
     return parseClassification(raw);
-  } catch (err) {
+  } catch {
     // Timeout, network error, or model unavailable — fail open
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(
-      `[contradiction] classification failed (${message}) — defaulting to ADD`,
-    );
     return { action: "ADD" };
   }
 }
@@ -183,9 +185,6 @@ function parseClassification(raw: string): ContradictionResult {
   }
 
   // Unparseable — default to ADD
-  console.error(
-    `[contradiction] unparseable response "${raw}" — defaulting to ADD`,
-  );
   return { action: "ADD" };
 }
 

package/lib/realtime.ts

@@ -29,6 +29,7 @@ import {
   isContradictionCheckable,
   findCandidates,
   classifyContradiction,
+  type ContradictionDecision,
 } from "./contradiction.js";
 
 /**
@@ -38,8 +39,10 @@ import {
  * 2. Generate embeddings with cache (instant semantic search)
  * 3. Insert into embeddings table
  */
-export async function indexAndEmbed(events: CaptureEvent[]): Promise<void> {
-  if (events.length === 0) return;
+export async function indexAndEmbed(
+  events: CaptureEvent[],
+): Promise<ContradictionDecision[]> {
+  if (events.length === 0) return [];
 
   const dbPath = getDatabasePath();
   if (!existsSync(dbPath)) {
@@ -63,8 +66,11 @@ export async function indexAndEmbed(events: CaptureEvent[]): Promise<void> {
     //    duplicates existing entries. NOOP skips the event, DELETE+ADD
     //    removes the old entry before inserting the new one.
     const eventsToIndex: CaptureEvent[] = [];
+    const decisions: ContradictionDecision[] = [];
     for (const event of events) {
       const source = getSourceForEvent(event);
+      const data = event.data as Record<string, unknown>;
+      const topic = String(data.topic || "");
 
       if (isContradictionCheckable(source)) {
         try {
@@ -73,37 +79,34 @@ export async function indexAndEmbed(events: CaptureEvent[]): Promise<void> {
             const result = await classifyContradiction(event, candidates);
 
             if (result.action === "NOOP") {
-              const data = event.data as Record<string, unknown>;
-              const topic = String(data.topic || "");
-              console.error(
-                `[contradiction] NOOP: skipped as redundant (topic: ${topic})`,
-              );
+              decisions.push({ action: "NOOP", topic, source });
               continue;
             }
 
             if (result.action === "DELETE+ADD" && result.deleteRowid) {
               deleteSearchAndEmbedding(db, result.deleteRowid);
-              const data = event.data as Record<string, unknown>;
-              const topic = String(data.topic || "");
-              console.error(
-                `[contradiction] DELETE+ADD: removed rowid ${result.deleteRowid}, topic: ${topic}`,
-              );
+              decisions.push({
+                action: "DELETE+ADD",
+                topic,
+                source,
+                deleteRowid: result.deleteRowid,
+              });
+            } else {
+              decisions.push({ action: "ADD", topic, source });
             }
             // ADD falls through to normal insert
           }
         } catch (err) {
           // Fail open — if contradiction check fails, proceed with ADD
           const message = err instanceof Error ? err.message : String(err);
-          console.error(
-            `[contradiction] check failed (${message}) — proceeding with ADD`,
-          );
+          decisions.push({ action: "ADD", topic, source, error: message });
         }
       }
 
       eventsToIndex.push(event);
     }
 
-    if (eventsToIndex.length === 0) return;
+    if (eventsToIndex.length === 0) return decisions;
 
     // 1. Insert into FTS5 and collect doc IDs
     const docIds: number[] = [];
@@ -120,6 +123,8 @@ export async function indexAndEmbed(events: CaptureEvent[]): Promise<void> {
     for (let i = 0; i < eventsToIndex.length; i++) {
       insertEmbedding(db, docIds[i], embeddings[i], eventsToIndex[i]);
     }
+
+    return decisions;
   } finally {
     db.close();
   }
@@ -319,12 +324,14 @@ function insertEmbedding(
 
   const embeddingBlob = serializeEmbedding(embedding);
 
+  const timestamp = event.timestamp || new Date().toISOString();
+
   const stmt = db.prepare(`
-    INSERT INTO embeddings (doc_id, chunk_idx, source, topic, type, embedding)
-    VALUES (?, 0, ?, ?, ?, ?)
+    INSERT INTO embeddings (doc_id, chunk_idx, source, topic, type, timestamp, embedding)
+    VALUES (?, 0, ?, ?, ?, ?, ?)
   `);
 
-  stmt.run(docId, source, topic, type, embeddingBlob);
+  stmt.run(docId, source, topic, type, timestamp, embeddingBlob);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidwire/lore",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Unified knowledge CLI - Search, list, and capture your indexed knowledge",
   "type": "module",
   "main": "./index.ts",