fix: replace priority-based search ranking with boost-based interleaving

Old ranking used hard source priority (all memories before all facts
before all messages), so message hits could never appear when 10+
memories existed. New ranking uses score * source_boost (memory=1.3,
fact=1.15, message=1.0) so strong message matches can beat weak
memory matches while still favoring higher-signal sources.

Author: ualtinok

scripts/context-dump/metrics.ts

@@ -98,13 +98,14 @@ export function buildDumpStats(originalMessages: DumpMessage[], transformedMessa
 		.map((msg, index) => {
 			const { id } = messageIdentity(msg, index)
 			const tokens = msg.info.tokens as Record<string, unknown>
+			const error = msg.info.error;
 			const cache = isRecord(tokens.cache) ? tokens.cache : {}
 			const total = typeof tokens.total === "number" ? tokens.total : 0
 			const input = typeof tokens.input === "number" ? tokens.input : 0
 			const output = typeof tokens.output === "number" ? tokens.output : 0
 			const cacheRead = typeof cache.read === "number" ? cache.read : 0
 			const cacheWrite = typeof cache.write === "number" ? cache.write : 0
-			const cacheBust = prevCacheRead > 0 && cacheRead < prevCacheRead
+			const cacheBust = prevCacheRead > 0 && cacheRead < prevCacheRead && (!error || error.name != "MessageAbortedError")
 			prevCacheRead = cacheRead
 
 			const time = isRecord(msg.info.time) ? msg.info.time : {}

scripts/context-dump/run-context-dump.ts

@@ -195,6 +195,8 @@ export async function runContextDump(sessionId: string): Promise<ContextDumpResu
 			historianWriteTimes,
 			previousBustTime,
 		)
+		//console.dir(entry);
+
 		previousBustTime = entry.time_completed
 		return [{ entry, probableCause }]
 	})

scripts/context-dump/types.ts

@@ -2,9 +2,14 @@ export interface DumpMessageInfo {
 	id?: string
 	role?: string
 	sessionID?: string
+	error?: MsgError
 	[key: string]: unknown
 }
 
+export interface MsgError {
+	name: string;
+	data: unknown[];
+}
 export interface DumpMessage {
 	info: DumpMessageInfo
 	parts: unknown[]

src/features/magic-context/search.test.ts

@@ -91,12 +91,14 @@ describe("unifiedSearch", () => {
         });
 
         expect(results).toHaveLength(4);
-        expect(results[0]?.source).toBe("memory");
-        expect(results[1]?.source).toBe("fact");
-        expect(results[2]?.source).toBe("message");
-        expect(results[3]?.source).toBe("message");
-        expect(results[2]).toMatchObject({ messageOrdinal: 1 });
-        expect(results[3]).toMatchObject({ messageOrdinal: 2 });
+        const sources = results.map((r) => r.source);
+        expect(sources).toContain("memory");
+        expect(sources).toContain("fact");
+        expect(sources).toContain("message");
+        // With boost-based ranking, sources interleave by effective score (score * boost)
+        // rather than strict priority ordering
+        const messageResults = results.filter((r) => r.source === "message");
+        expect(messageResults).toHaveLength(2);
         expect(embeddingQueries).toEqual(["ranked search"]);
         expect(getMemoryById(db, memory.id)?.retrievalCount).toBe(1);
     });

src/features/magic-context/search.ts

@@ -22,9 +22,10 @@ const SEMANTIC_WEIGHT = 0.7;
 const FTS_WEIGHT = 0.3;
 const SINGLE_SOURCE_PENALTY = 0.8;
 const RESULT_PREVIEW_LIMIT = 220;
-const MEMORY_SOURCE_PRIORITY = 0;
-const FACT_SOURCE_PRIORITY = 1;
-const MESSAGE_SOURCE_PRIORITY = 2;
+/** Source boost multipliers for unified ranking — higher-signal sources get a mild score boost. */
+const MEMORY_SOURCE_BOOST = 1.3;
+const FACT_SOURCE_BOOST = 1.15;
+const MESSAGE_SOURCE_BOOST = 1.0;
 
 interface MessageSearchRow {
     messageOrdinal?: number | string;
@@ -378,25 +379,23 @@ function searchMessages(args: {
         .filter((result): result is MessageSearchResult => result !== null);
 }
 
-function getSourcePriority(result: UnifiedSearchResult): number {
+function getSourceBoost(result: UnifiedSearchResult): number {
     switch (result.source) {
         case "memory":
-            return MEMORY_SOURCE_PRIORITY;
+            return MEMORY_SOURCE_BOOST;
         case "fact":
-            return FACT_SOURCE_PRIORITY;
+            return FACT_SOURCE_BOOST;
         case "message":
-            return MESSAGE_SOURCE_PRIORITY;
+            return MESSAGE_SOURCE_BOOST;
     }
 }
 
 function compareUnifiedResults(left: UnifiedSearchResult, right: UnifiedSearchResult): number {
-    const priorityDiff = getSourcePriority(left) - getSourcePriority(right);
-    if (priorityDiff !== 0) {
-        return priorityDiff;
-    }
+    const leftEffective = left.score * getSourceBoost(left);
+    const rightEffective = right.score * getSourceBoost(right);
 
-    if (right.score !== left.score) {
-        return right.score - left.score;
+    if (rightEffective !== leftEffective) {
+        return rightEffective - leftEffective;
     }
 
     if (left.source === "memory" && right.source === "memory") {