@voidwire/lore 0.5.5 → 0.6.1

package/cli.ts

@@ -35,6 +35,7 @@ import {
   captureKnowledge,
   captureNote,
   captureTeaching,
+  captureObservation,
   semanticSearch,
   formatBriefSearch,
   hasEmbeddings,
@@ -48,6 +49,9 @@ import {
   type NoteInput,
   type TeachingInput,
   type KnowledgeCaptureType,
+  type ObservationInput,
+  type ObservationSubtype,
+  type ObservationConfidence,
 } from "./index";
 
 // ============================================================================
@@ -521,14 +525,14 @@ Examples:
 function handleCaptureTask(args: string[]): void {
   const parsed = parseArgs(args);
 
-  const required = ["project", "name", "problem", "solution"];
+  const required = ["topic", "name", "problem", "solution"];
   const missing = required.filter((f) => !parsed.has(f));
   if (missing.length > 0) {
     fail(`Missing required fields: ${missing.join(", ")}`);
   }
 
   const input: TaskInput = {
-    project: parsed.get("project")!,
+    topic: parsed.get("topic")!,
     name: parsed.get("name")!,
     problem: parsed.get("problem")!,
     solution: parsed.get("solution")!,
@@ -536,7 +540,7 @@ function handleCaptureTask(args: string[]): void {
     discoveries: parseList(parsed.get("discoveries")),
     deviations: parsed.get("deviations"),
     pattern: parsed.get("pattern"),
-    keywords: parseList(parsed.get("keywords")),
+    tags: parseList(parsed.get("tags")),
     tech: parseList(parsed.get("tech")),
     difficulty: parsed.get("difficulty"),
   };
@@ -556,16 +560,16 @@ function handleCaptureTask(args: string[]): void {
 function handleCaptureKnowledge(args: string[]): void {
   const parsed = parseArgs(args);
 
-  const required = ["context", "text", "type"];
+  const required = ["topic", "text", "subtype"];
   const missing = required.filter((f) => !parsed.has(f));
   if (missing.length > 0) {
     fail(`Missing required fields: ${missing.join(", ")}`);
   }
 
   const input: KnowledgeInput = {
-    context: parsed.get("context")!,
-    text: parsed.get("text")!,
-    type: parsed.get("type")! as KnowledgeCaptureType,
+    topic: parsed.get("topic")!,
+    content: parsed.get("text")!,
+    subtype: parsed.get("subtype")! as KnowledgeCaptureType,
   };
 
   const result = captureKnowledge(input);
@@ -588,9 +592,9 @@ function handleCaptureNote(args: string[]): void {
   }
 
   const input: NoteInput = {
-    text: parsed.get("text")!,
+    content: parsed.get("text")!,
     tags: parseList(parsed.get("tags")),
-    context: parsed.get("context"),
+    topic: parsed.get("topic"),
   };
 
   const result = captureNote(input);
@@ -608,16 +612,16 @@ function handleCaptureNote(args: string[]): void {
 function handleCaptureTeaching(args: string[]): void {
   const parsed = parseArgs(args);
 
-  const required = ["domain", "confidence", "text"];
+  const required = ["topic", "confidence", "text"];
   const missing = required.filter((f) => !parsed.has(f));
   if (missing.length > 0) {
     fail(`Missing required fields: ${missing.join(", ")}`);
   }
 
   const input: TeachingInput = {
-    domain: parsed.get("domain")!,
+    topic: parsed.get("topic")!,
     confidence: parsed.get("confidence")!,
-    text: parsed.get("text")!,
+    content: parsed.get("text")!,
     source: parsed.get("source"),
   };
 
@@ -633,13 +637,44 @@ function handleCaptureTeaching(args: string[]): void {
   }
 }
 
+function handleCaptureObservation(args: string[]): void {
+  const parsed = parseArgs(args);
+
+  const required = ["topic", "subtype", "confidence", "text"];
+  const missing = required.filter((f) => !parsed.has(f));
+  if (missing.length > 0) {
+    fail(`Missing required fields: ${missing.join(", ")}`);
+  }
+
+  const input: ObservationInput = {
+    topic: parsed.get("topic")!,
+    content: parsed.get("text")!,
+    subtype: parsed.get("subtype")! as ObservationSubtype,
+    confidence: parsed.get("confidence")! as ObservationConfidence,
+    source: parsed.get("source"),
+  };
+
+  const result = captureObservation(input);
+  output(result);
+
+  if (result.success) {
+    console.error("✅ Observation logged");
+    process.exit(0);
+  } else {
+    console.error(`❌ ${result.error}`);
+    process.exit(2);
+  }
+}
+
 function handleCapture(args: string[]): void {
   if (hasFlag(args, "help")) {
     showCaptureHelp();
   }
 
   if (args.length === 0) {
-    fail("Missing capture type. Use: task, knowledge, or note");
+    fail(
+      "Missing capture type. Use: task, knowledge, note, teaching, or observation",
+    );
   }
 
   const captureType = args[0];
@@ -658,9 +693,12 @@ function handleCapture(args: string[]): void {
     case "teaching":
       handleCaptureTeaching(captureArgs);
       break;
+    case "observation":
+      handleCaptureObservation(captureArgs);
+      break;
     default:
       fail(
-        `Unknown capture type: ${captureType}. Use: task, knowledge, note, or teaching`,
+        `Unknown capture type: ${captureType}. Use: task, knowledge, note, teaching, or observation`,
       );
   }
 }
@@ -708,34 +746,42 @@ List Options:
 
 Capture Types:
   task              Log task completion
-    --project       Project name (required)
+    --topic         Project/topic name (required)
     --name          Task name (required)
     --problem       Problem solved (required)
     --solution      Solution pattern (required)
 
   knowledge         Log insight
-    --context       Context/project name (required)
+    --topic         Topic/context name (required)
     --text          Insight text (required)
-    --type          Type: decision, learning, gotcha, preference (required)
+    --subtype       Type: decision, learning, gotcha, preference (required)
 
   note              Quick note
     --text          Note content (required)
     --tags          Comma-separated tags
-    --context       Optional context
+    --topic         Optional topic/context
 
   teaching          Log teaching/learning
-    --domain        Subject area (required)
+    --topic         Subject area (required)
     --confidence    Certainty level (required)
     --text          Teaching content (required)
     --source        Optional source identifier
 
+  observation       Log model observation
+    --topic         Observation topic (required)
+    --subtype       Type: term, style, pattern, preference, context (required)
+    --confidence    Level: inferred, stated, verified (required)
+    --text          Observation content (required)
+    --source        Optional source identifier
+
 Examples:
   lore search "authentication"
   lore search blogs "typescript patterns"
   lore sources
   lore list development
   lore list commits --limit 10 --format human
-  lore capture knowledge --context=lore --text="Unified CLI works" --type=learning
+  lore capture knowledge --topic=lore --text="Unified CLI works" --subtype=learning
+  lore capture observation --topic=vocabulary --subtype=term --confidence=stated --text="Uses unified schema"
 `);
   process.exit(0);
 }
@@ -947,12 +993,13 @@ Usage:
   lore capture knowledge                Log insight/learning
   lore capture note                     Quick note
   lore capture teaching                 Log teaching moment
+  lore capture observation              Log model observation
 
 Capture Types:
 
   task - Log completed development task
     Required:
-      --project       Project name
+      --topic         Project/topic name
       --name          Task name
       --problem       Problem solved
       --solution      Solution pattern
@@ -961,36 +1008,46 @@ Capture Types:
       --discoveries   Comma-separated discoveries
       --deviations    Deviation from plan
       --pattern       Pattern name
-      --keywords      Comma-separated keywords
+      --tags          Comma-separated tags
       --tech          Comma-separated technologies
       --difficulty    Difficulty level
 
   knowledge - Log insight or learning
     Required:
-      --context       Context/project name
+      --topic         Topic/context name
       --text          Insight text
-      --type          Type: decision, learning, gotcha, preference
+      --subtype       Type: decision, learning, gotcha, preference, project, conversation, knowledge
 
   note - Quick note capture
     Required:
       --text          Note content
     Optional:
       --tags          Comma-separated tags
-      --context       Optional context
+      --topic         Optional topic/context
 
   teaching - Log teaching or learning moment
     Required:
-      --domain        Subject area (e.g., typescript, architecture)
+      --topic         Subject area (e.g., typescript, architecture)
       --confidence    Certainty level (e.g., high, medium, low)
       --text          Teaching content
     Optional:
       --source        Source identifier (defaults to "manual")
 
+  observation - Log model observation about user patterns
+    Required:
+      --topic         Observation topic
+      --subtype       Type: term, style, pattern, preference, context
+      --confidence    Level: inferred, stated, verified
+      --text          Observation content
+    Optional:
+      --source        Source identifier (defaults to "auto")
+
 Examples:
-  lore capture task --project=lore --name="Add help" --problem="No subcommand help" --solution="Added per-command help functions"
-  lore capture knowledge --context=lore --text="Unified CLI works" --type=learning
+  lore capture task --topic=lore --name="Add help" --problem="No subcommand help" --solution="Added per-command help functions"
+  lore capture knowledge --topic=lore --text="Unified CLI works" --subtype=learning
   lore capture note --text="Remember to update docs" --tags=docs,todo
-  lore capture teaching --domain=patterns --confidence=high --text="Prefer composition over inheritance"
+  lore capture teaching --topic=patterns --confidence=high --text="Prefer composition over inheritance"
+  lore capture observation --topic=vocabulary --subtype=term --confidence=stated --text="Uses 'unified schema'"
 `);
   process.exit(0);
 }

package/index.ts

@@ -68,6 +68,7 @@ export {
   captureTeaching,
   captureInsight,
   captureLearning,
+  captureObservation,
   type CaptureResult,
   type KnowledgeInput,
   type KnowledgeCaptureType,
@@ -77,6 +78,9 @@ export {
   type InsightInput,
   type InsightType,
   type LearningInput,
+  type ObservationInput,
+  type ObservationSubtype,
+  type ObservationConfidence,
   type CaptureEvent,
 } from "./lib/capture";
 

package/lib/capture.ts

@@ -25,13 +25,13 @@ export type KnowledgeCaptureType =
   | "knowledge";
 
 export interface KnowledgeInput {
-  context: string;
-  text: string;
-  type: KnowledgeCaptureType;
+  topic: string;
+  content: string;
+  subtype: KnowledgeCaptureType;
 }
 
 export interface TaskInput {
-  project: string;
+  topic: string;
   name: string;
   problem: string;
   solution: string;
@@ -39,21 +39,21 @@ export interface TaskInput {
   discoveries?: string[];
   deviations?: string;
   pattern?: string;
-  keywords?: string[];
+  tags?: string[];
   tech?: string[];
   difficulty?: string;
 }
 
 export interface NoteInput {
-  text: string;
+  content: string;
   tags?: string[];
-  context?: string;
+  topic?: string;
 }
 
 export interface TeachingInput {
-  domain: string;
+  topic: string;
   confidence: string;
-  text: string;
+  content: string;
   source?: string;
 }
 
@@ -67,35 +67,52 @@ export type InsightType =
 
 export interface InsightInput {
   session_id: string;
-  project: string;
-  insight_type: InsightType;
-  text: string;
+  topic: string;
+  subtype: InsightType;
+  content: string;
   source: "auto";
 }
 
 export interface LearningInput {
   topic: string; // "spanish", "guitar", "kubernetes" - the learning topic
   persona: string; // "marcus", "elena", etc.
-  progress: string; // "Covered verb conjugations, struggles with subjunctive"
+  content: string; // "Covered verb conjugations, struggles with subjunctive"
   session_summary?: string; // Longer form session notes
 }
 
+export type ObservationSubtype =
+  | "term"
+  | "style"
+  | "pattern"
+  | "preference"
+  | "context";
+
+export type ObservationConfidence = "inferred" | "stated" | "verified";
+
+export interface ObservationInput {
+  topic: string;
+  content: string;
+  subtype: ObservationSubtype;
+  confidence: ObservationConfidence;
+  source?: string;
+}
+
 interface TaskEvent {
   event: "captured";
   type: "task";
   timestamp: string;
   data: {
-    project: string;
-    task_name: string;
-    problem_solved: string;
-    solution_pattern: string;
-    code_snippet?: string;
+    topic: string;
+    name: string;
+    problem: string;
+    solution: string;
+    code?: string;
     discoveries?: string[];
     deviations?: string;
-    reusable_pattern?: string;
-    keywords?: string[];
-    tech_used?: string[];
-    difficulty_notes?: string;
+    pattern?: string;
+    tags?: string[];
+    tech?: string[];
+    difficulty?: string;
   };
 }
 
@@ -104,9 +121,9 @@ interface KnowledgeEvent {
   type: "knowledge";
   timestamp: string;
   data: {
-    context: string;
-    capture: string;
-    type: KnowledgeCaptureType;
+    topic: string;
+    content: string;
+    subtype: KnowledgeCaptureType;
   };
 }
 
@@ -117,7 +134,7 @@ interface NoteEvent {
   data: {
     content: string;
     tags?: string[];
-    context?: string;
+    topic?: string;
   };
 }
 
@@ -126,9 +143,9 @@ interface TeachingEvent {
   type: "teaching";
   timestamp: string;
   data: {
-    domain: string;
+    topic: string;
     confidence: string;
-    text: string;
+    content: string;
     source: string;
   };
 }
@@ -139,9 +156,9 @@ interface InsightEvent {
   timestamp: string;
   data: {
     session_id: string;
-    project: string;
-    insight_type: InsightType;
-    text: string;
+    topic: string;
+    subtype: InsightType;
+    content: string;
     source: "auto";
   };
 }
@@ -153,18 +170,32 @@ interface LearningEvent {
   data: {
     topic: string; // Learning topic (spanish, guitar, etc.)
     persona: string;
-    progress: string;
+    content: string;
     session_summary?: string;
   };
 }
 
+interface ObservationEvent {
+  event: "captured";
+  type: "observation";
+  timestamp: string;
+  data: {
+    topic: string;
+    content: string;
+    subtype: ObservationSubtype;
+    confidence: ObservationConfidence;
+    source: string;
+  };
+}
+
 type CaptureEvent =
   | TaskEvent
   | KnowledgeEvent
   | NoteEvent
   | TeachingEvent
   | InsightEvent
-  | LearningEvent;
+  | LearningEvent
+  | ObservationEvent;
 
 function getLogPath(): string {
   const dataHome =
@@ -217,10 +248,10 @@ const VALID_KNOWLEDGE_TYPES: KnowledgeCaptureType[] = [
  * Capture a knowledge insight
  */
 export function captureKnowledge(input: KnowledgeInput): CaptureResult {
-  if (!VALID_KNOWLEDGE_TYPES.includes(input.type)) {
+  if (!VALID_KNOWLEDGE_TYPES.includes(input.subtype)) {
     return {
       success: false,
-      error: `Invalid type: ${input.type}. Must be one of: ${VALID_KNOWLEDGE_TYPES.join(", ")}`,
+      error: `Invalid subtype: ${input.subtype}. Must be one of: ${VALID_KNOWLEDGE_TYPES.join(", ")}`,
     };
   }
 
@@ -229,9 +260,9 @@ export function captureKnowledge(input: KnowledgeInput): CaptureResult {
     type: "knowledge",
     timestamp: "",
     data: {
-      context: input.context,
-      capture: input.text,
-      type: input.type,
+      topic: input.topic,
+      content: input.content,
+      subtype: input.subtype,
     },
   };
 
@@ -247,17 +278,17 @@ export function captureTask(input: TaskInput): CaptureResult {
     type: "task",
     timestamp: "",
     data: {
-      project: input.project,
-      task_name: input.name,
-      problem_solved: input.problem,
-      solution_pattern: input.solution,
-      code_snippet: input.code,
+      topic: input.topic,
+      name: input.name,
+      problem: input.problem,
+      solution: input.solution,
+      code: input.code,
       discoveries: input.discoveries,
       deviations: input.deviations,
-      reusable_pattern: input.pattern,
-      keywords: input.keywords,
-      tech_used: input.tech,
-      difficulty_notes: input.difficulty,
+      pattern: input.pattern,
+      tags: input.tags,
+      tech: input.tech,
+      difficulty: input.difficulty,
     },
   };
 
@@ -273,9 +304,9 @@ export function captureNote(input: NoteInput): CaptureResult {
     type: "note",
     timestamp: "",
     data: {
-      content: input.text,
+      content: input.content,
       tags: input.tags,
-      context: input.context,
+      topic: input.topic,
     },
   };
 
@@ -291,9 +322,9 @@ export function captureTeaching(input: TeachingInput): CaptureResult {
     type: "teaching",
     timestamp: "",
     data: {
-      domain: input.domain,
+      topic: input.topic,
       confidence: input.confidence,
-      text: input.text,
+      content: input.content,
       source: input.source || "manual",
     },
   };
@@ -314,10 +345,10 @@ const VALID_INSIGHT_TYPES: InsightType[] = [
  * Capture an auto-extracted insight from llm-summarize
  */
 export function captureInsight(input: InsightInput): CaptureResult {
-  if (!VALID_INSIGHT_TYPES.includes(input.insight_type)) {
+  if (!VALID_INSIGHT_TYPES.includes(input.subtype)) {
     return {
       success: false,
-      error: `Invalid insight_type: ${input.insight_type}. Must be one of: ${VALID_INSIGHT_TYPES.join(", ")}`,
+      error: `Invalid subtype: ${input.subtype}. Must be one of: ${VALID_INSIGHT_TYPES.join(", ")}`,
     };
   }
 
@@ -327,9 +358,9 @@ export function captureInsight(input: InsightInput): CaptureResult {
     timestamp: "",
     data: {
       session_id: input.session_id,
-      project: input.project,
-      insight_type: input.insight_type,
-      text: input.text,
+      topic: input.topic,
+      subtype: input.subtype,
+      content: input.content,
       source: input.source,
     },
   };
@@ -341,10 +372,10 @@ export function captureInsight(input: InsightInput): CaptureResult {
  * Capture a learning session progress
  */
 export function captureLearning(input: LearningInput): CaptureResult {
-  if (!input.topic || !input.persona || !input.progress) {
+  if (!input.topic || !input.persona || !input.content) {
     return {
       success: false,
-      error: "Missing required fields: topic, persona, progress",
+      error: "Missing required fields: topic, persona, content",
     };
   }
 
@@ -355,7 +386,7 @@ export function captureLearning(input: LearningInput): CaptureResult {
     data: {
       topic: input.topic,
       persona: input.persona,
-      progress: input.progress,
+      content: input.content,
       session_summary: input.session_summary,
     },
   };
@@ -363,4 +394,52 @@ export function captureLearning(input: LearningInput): CaptureResult {
   return writeEvent(event);
 }
 
+const VALID_OBSERVATION_SUBTYPES: ObservationSubtype[] = [
+  "term",
+  "style",
+  "pattern",
+  "preference",
+  "context",
+];
+
+const VALID_OBSERVATION_CONFIDENCE: ObservationConfidence[] = [
+  "inferred",
+  "stated",
+  "verified",
+];
+
+/**
+ * Capture a model observation about user patterns
+ */
+export function captureObservation(input: ObservationInput): CaptureResult {
+  if (!VALID_OBSERVATION_SUBTYPES.includes(input.subtype)) {
+    return {
+      success: false,
+      error: `Invalid subtype: ${input.subtype}. Must be one of: ${VALID_OBSERVATION_SUBTYPES.join(", ")}`,
+    };
+  }
+
+  if (!VALID_OBSERVATION_CONFIDENCE.includes(input.confidence)) {
+    return {
+      success: false,
+      error: `Invalid confidence: ${input.confidence}. Must be one of: ${VALID_OBSERVATION_CONFIDENCE.join(", ")}`,
+    };
+  }
+
+  const event: ObservationEvent = {
+    event: "captured",
+    type: "observation",
+    timestamp: "",
+    data: {
+      topic: input.topic,
+      content: input.content,
+      subtype: input.subtype,
+      confidence: input.confidence,
+      source: input.source || "auto",
+    },
+  };
+
+  return writeEvent(event);
+}
+
 export type { CaptureEvent };

package/lib/list.ts

@@ -29,7 +29,8 @@ export type Source =
   | "teachings"
   | "sessions"
   | "insights"
-  | "learnings";
+  | "learnings"
+  | "observations";
 
 export const SOURCES: Source[] = [
   "development",
@@ -51,6 +52,7 @@ export const SOURCES: Source[] = [
   "sessions",
   "insights",
   "learnings",
+  "observations",
 ];
 
 // Sources that query the 'personal' source with type filter
@@ -69,10 +71,11 @@ const PROJECT_FIELD: Record<string, string> = {
   commits: "project",
   sessions: "project",
   tasks: "project",
-  insights: "project",
+  insights: "topic",
   captures: "topic",
   teachings: "topic",
   learnings: "topic",
+  observations: "topic",
 };
 
 export interface ListOptions {
@@ -158,23 +161,28 @@ function queryPersonalType(
   type: string,
   limit?: number,
 ): ListEntry[] {
-  // Query personal source, then filter by type in metadata
-  const sql = limit
-    ? `SELECT title, content, metadata FROM search WHERE source = 'personal' LIMIT ?`
-    : `SELECT title, content, metadata FROM search WHERE source = 'personal'`;
+  // Filter by type in SQL, not JS - avoids LIMIT truncation bug
+  let sql = `
+    SELECT title, content, metadata FROM search
+    WHERE source = 'personal'
+      AND json_extract(metadata, '$.type') = ?
+    ORDER BY json_extract(metadata, '$.timestamp') DESC
+  `;
+  const params: (string | number)[] = [type];
 
-  const stmt = db.prepare(sql);
-  const rows = (limit ? stmt.all(limit * 10) : stmt.all()) as RawRow[]; // Over-fetch for filtering
+  if (limit) {
+    sql += " LIMIT ?";
+    params.push(limit);
+  }
 
-  const filtered = rows
-    .map((row) => ({
-      title: row.title,
-      content: row.content,
-      metadata: JSON.parse(row.metadata || "{}"),
-    }))
-    .filter((entry) => entry.metadata.type === type);
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params) as RawRow[];
 
-  return limit ? filtered.slice(0, limit) : filtered;
+  return rows.map((row) => ({
+    title: row.title,
+    content: row.content,
+    metadata: JSON.parse(row.metadata || "{}"),
+  }));
 }
 
 /**

package/lib/projects.ts

@@ -14,10 +14,11 @@ const PROJECT_FIELD: Record<string, string> = {
   commits: "project",
   sessions: "project",
   tasks: "project",
-  insights: "project",
+  insights: "topic",
   captures: "topic",
   teachings: "topic",
   learnings: "topic",
+  observations: "topic",
 };
 
 function getDatabasePath(): string {

package/lib/semantic.ts

@@ -43,10 +43,11 @@ const PROJECT_FIELD: Record<string, string> = {
   commits: "project",
   sessions: "project",
   tasks: "project",
-  insights: "project",
+  insights: "topic",
   captures: "topic",
   teachings: "topic",
   learnings: "topic",
+  observations: "topic",
 };
 
 const MODEL_NAME = "nomic-ai/nomic-embed-text-v1.5";
@@ -192,70 +193,42 @@ export async function semanticSearch(
 
     // KNN query - 1:1 mapping between search rows and embeddings
     // Content is pre-chunked at ingest time
+    // source/topic partition columns enable filtered KNN (filter BEFORE search)
     let sql: string;
     const params: (Uint8Array | string | number)[] = [queryBlob];
 
+    // Build KNN query with optional partition filters
+    const conditions = ["e.embedding MATCH ?", "k = ?"];
+    params.push(limit);
+
     if (options.source) {
-      // Filter by e.source (partition column) for KNN pre-filtering
-      // This filters BEFORE KNN, not after — critical for domain-specific search
-      sql = `
-        SELECT
-          s.source,
-          s.title,
-          s.content,
-          s.metadata,
-          e.distance
-        FROM embeddings e
-        JOIN search s ON e.doc_id = s.rowid
-        WHERE e.embedding MATCH ?
-          AND k = ?
-          AND e.source = ?
-        ORDER BY e.distance
-        LIMIT ?
-      `;
-      params.push(limit);
+      conditions.push("e.source = ?");
       params.push(options.source);
-      params.push(limit);
-    } else {
-      sql = `
-        SELECT
-          s.source,
-          s.title,
-          s.content,
-          s.metadata,
-          e.distance
-        FROM embeddings e
-        JOIN search s ON e.doc_id = s.rowid
-        WHERE e.embedding MATCH ?
-          AND k = ?
-        ORDER BY e.distance
-        LIMIT ?
-      `;
-      params.push(limit);
-      params.push(limit);
     }
 
-    const stmt = db.prepare(sql);
-    const results = stmt.all(...params) as SemanticResult[];
-
-    // Post-filter by project if specified
-    // KNN WHERE clause doesn't support json_extract on joined metadata,
-    // so we filter after the query returns
     if (options.project) {
-      return results.filter((result) => {
-        const field = PROJECT_FIELD[result.source];
-        if (!field) return false;
-
-        try {
-          const metadata = JSON.parse(result.metadata);
-          return metadata[field] === options.project;
-        } catch {
-          // Skip results with malformed metadata
-          return false;
-        }
-      });
+      conditions.push("e.topic = ?");
+      params.push(options.project);
     }
 
+    sql = `
+      SELECT
+        s.source,
+        s.title,
+        s.content,
+        s.metadata,
+        e.distance
+      FROM embeddings e
+      JOIN search s ON e.doc_id = s.rowid
+      WHERE ${conditions.join("\n        AND ")}
+      ORDER BY e.distance
+      LIMIT ?
+    `;
+    params.push(limit);
+
+    const stmt = db.prepare(sql);
+    const results = stmt.all(...params) as SemanticResult[];
+
     return results;
   } finally {
     db.close();

package/package.json

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