recallx 1.0.0 → 1.0.2

package/app/server/repositories.js

@@ -34,6 +34,7 @@ const workspaceInboxSource = {
     actorLabel: "RecallX",
     toolName: "recallx-system"
 };
+const DEFAULT_WORKSPACE_SEMANTIC_FALLBACK_MODE = "strict_zero";
 function normalizeSearchText(value) {
     return (value ?? "").normalize("NFKC").toLowerCase();
 }
@@ -52,32 +53,140 @@ function createSearchFieldMatcher(query) {
         matchTerms: tokens.length ? tokens : [trimmedQuery]
     };
 }
-function collectMatchedFields(matcher, candidates) {
+function collectSearchFieldSignals(matcher, candidates) {
     if (!matcher) {
-        return [];
+        return {
+            matchedFields: [],
+            exactFields: [],
+            matchedTermCount: 0,
+            totalTermCount: 0
+        };
     }
-    const matches = new Set();
+    const matchedFields = new Set();
+    const exactFields = new Set();
+    const matchedTerms = new Set();
     for (const candidate of candidates) {
         const haystack = normalizeSearchText(candidate.value);
         if (!haystack) {
             continue;
         }
-        if (haystack.includes(matcher.trimmedQuery) || matcher.matchTerms.some((term) => haystack.includes(term))) {
-            matches.add(candidate.field);
+        const exactMatch = haystack.includes(matcher.trimmedQuery);
+        const termMatches = matcher.matchTerms.filter((term) => haystack.includes(term));
+        if (!exactMatch && !termMatches.length) {
+            continue;
+        }
+        matchedFields.add(candidate.field);
+        if (exactMatch) {
+            exactFields.add(candidate.field);
+        }
+        for (const term of termMatches) {
+            matchedTerms.add(term);
+        }
+    }
+    return {
+        matchedFields: [...matchedFields],
+        exactFields: [...exactFields],
+        matchedTermCount: matchedTerms.size,
+        totalTermCount: matcher.matchTerms.length
+    };
+}
+function classifyNodeLexicalQuality(strategy, signals) {
+    if (strategy === "browse" || strategy === "semantic" || !signals.matchedFields.length) {
+        return "none";
+    }
+    if (strategy === "fallback_token") {
+        return "weak";
+    }
+    const strongExactFields = new Set(["title", "summary", "tags"]);
+    if (signals.exactFields.some((field) => strongExactFields.has(field))) {
+        return "strong";
+    }
+    const termCoverage = signals.totalTermCount > 0 ? signals.matchedTermCount / signals.totalTermCount : 0;
+    if (strategy === "fts" && termCoverage >= 0.6 && signals.matchedFields.some((field) => strongExactFields.has(field))) {
+        return "strong";
+    }
+    return "weak";
+}
+function classifyActivityLexicalQuality(strategy, signals) {
+    if (strategy === "browse" || strategy === "semantic" || !signals.matchedFields.length) {
+        return "none";
+    }
+    if (strategy === "fallback_token") {
+        return "weak";
+    }
+    if (signals.exactFields.some((field) => field === "targetNodeTitle" || field === "body" || field === "activityType")) {
+        return "strong";
+    }
+    const termCoverage = signals.totalTermCount > 0 ? signals.matchedTermCount / signals.totalTermCount : 0;
+    return strategy === "fts" && termCoverage >= 0.6 ? "strong" : "weak";
+}
+function summarizeLexicalQuality(items) {
+    if (items.some((item) => item.lexicalQuality === "strong")) {
+        return "strong";
+    }
+    if (items.some((item) => item.lexicalQuality === "weak")) {
+        return "weak";
+    }
+    return "none";
+}
+function computeWorkspaceResultComposition(input) {
+    if (input.nodeCount === 0 && input.activityCount === 0) {
+        return "empty";
+    }
+    if (input.nodeCount > 0 && input.activityCount === 0) {
+        return input.semanticUsed ? "semantic_node_only" : "node_only";
+    }
+    if (input.nodeCount === 0 && input.activityCount > 0) {
+        return "activity_only";
+    }
+    return input.semanticUsed ? "semantic_mixed" : "mixed";
+}
+function mergeLexicalQuality(left, right) {
+    if (left === "strong" || right === "strong") {
+        return "strong";
+    }
+    if (left === "weak" || right === "weak") {
+        return "weak";
+    }
+    return "none";
+}
+function mergeNodeSearchItems(primary, secondary) {
+    const merged = [...primary];
+    const indexById = new Map(primary.map((item, index) => [item.id, index]));
+    for (const item of secondary) {
+        const existingIndex = indexById.get(item.id);
+        if (existingIndex == null) {
+            indexById.set(item.id, merged.length);
+            merged.push(item);
+            continue;
         }
+        const existing = merged[existingIndex];
+        merged[existingIndex] = {
+            ...existing,
+            lexicalQuality: existing.lexicalQuality === "strong" ? "strong" : item.lexicalQuality ?? existing.lexicalQuality,
+            matchReason: existing.matchReason && item.matchReason
+                ? mergeMatchReasons(existing.matchReason, item.matchReason, existing.matchReason.strategy)
+                : existing.matchReason ?? item.matchReason
+        };
     }
-    return [...matches];
+    return merged;
 }
-function buildSearchMatchReason(strategy, matchedFields) {
+function buildSearchMatchReason(strategy, matchedFields, extras = {}) {
     return {
         strategy,
-        matchedFields
+        matchedFields,
+        ...(extras.strength ? { strength: extras.strength } : {}),
+        ...(extras.termCoverage != null ? { termCoverage: extras.termCoverage } : {})
     };
 }
 function mergeMatchReasons(left, right, strategy) {
     return {
         strategy,
-        matchedFields: Array.from(new Set([...(left?.matchedFields ?? []), ...(right?.matchedFields ?? [])]))
+        matchedFields: Array.from(new Set([...(left?.matchedFields ?? []), ...(right?.matchedFields ?? [])])),
+        strength: left?.strength ?? right?.strength,
+        termCoverage: typeof left?.termCoverage === "number" || typeof right?.termCoverage === "number"
+            ? Math.max(left?.termCoverage ?? 0, right?.termCoverage ?? 0)
+            : null
     };
 }
 function computeWorkspaceRankBonus(index, total) {
@@ -87,8 +196,18 @@ function computeWorkspaceRankBonus(index, total) {
     return Math.max(0, Math.round(((total - index) / total) * 24));
 }
 function computeWorkspaceSmartScore(input) {
+    const matchBonus = input.matchReason?.strategy === "semantic"
+        ? 3
+        : input.lexicalQuality === "strong"
+            ? 10
+            : input.lexicalQuality === "weak"
+                ? input.matchReason?.strategy === "fallback_token"
+                    ? 1
+                    : 4
+                : 0;
     return (computeWorkspaceRankBonus(input.index, input.total) +
         computeWorkspaceRecencyBonusFromAge(input.nowMs - new Date(input.timestamp).getTime(), input.resultType) +
+        matchBonus +
         (input.resultType === "activity" ? 4 : 0) -
         (input.contested ? 20 : 0));
 }
@@ -132,6 +251,9 @@ function readNumberSetting(settings, key, fallback) {
     const value = settings[key];
     return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
+function normalizeWorkspaceSemanticFallbackMode(value) {
+    return value === "no_strong_node_hit" ? "no_strong_node_hit" : DEFAULT_WORKSPACE_SEMANTIC_FALLBACK_MODE;
+}
 function normalizeSemanticIndexBackend(value) {
     return value === "sqlite-vec" ? "sqlite-vec" : "sqlite";
 }
@@ -171,7 +293,9 @@ function readSemanticIndexSettingSnapshot(settings, runtime) {
         indexBackend: resolveActiveSemanticIndexBackend(configuredIndexBackend, runtime.sqliteVecLoaded),
         extensionStatus: resolveSemanticExtensionStatus(configuredIndexBackend, runtime.sqliteVecLoaded),
         extensionLoadError: configuredIndexBackend === "sqlite-vec" && !runtime.sqliteVecLoaded ? runtime.sqliteVecLoadError : null,
-        chunkEnabled: readBooleanSetting(settings, "search.semantic.chunk.enabled", false)
+        chunkEnabled: readBooleanSetting(settings, "search.semantic.chunk.enabled", false),
+        workspaceFallbackEnabled: readBooleanSetting(settings, "search.semantic.workspaceFallback.enabled", false),
+        workspaceFallbackMode: normalizeWorkspaceSemanticFallbackMode(settings["search.semantic.workspaceFallback.mode"])
     };
 }
 function shouldReindexForSemanticConfigChange(previous, next) {
@@ -601,7 +725,8 @@ export class RecallXRepository {
             "search.semantic.indexBackend",
             "search.semantic.chunk.enabled",
             "search.semantic.chunk.aggregation",
-            "search.semantic.workspaceFallback.enabled"
+            "search.semantic.workspaceFallback.enabled",
+            "search.semantic.workspaceFallback.mode"
         ]);
         return {
             ...readSemanticIndexSettingSnapshot(settings, {
@@ -609,7 +734,8 @@ export class RecallXRepository {
                 sqliteVecLoadError: this.sqliteVecRuntime.loadError
             }),
             chunkAggregation: normalizeSemanticChunkAggregation(settings["search.semantic.chunk.aggregation"]),
-            workspaceFallbackEnabled: readBooleanSetting(settings, "search.semantic.workspaceFallback.enabled", false)
+            workspaceFallbackEnabled: readBooleanSetting(settings, "search.semantic.workspaceFallback.enabled", false),
+            workspaceFallbackMode: normalizeWorkspaceSemanticFallbackMode(settings["search.semantic.workspaceFallback.mode"])
         };
     }
     getSemanticAugmentationSettings() {
@@ -1010,6 +1136,8 @@ export class RecallXRepository {
             "search.semantic.model",
             "search.semantic.indexBackend",
             "search.semantic.chunk.enabled",
+            "search.semantic.workspaceFallback.enabled",
+            "search.semantic.workspaceFallback.mode",
             "search.semantic.last_backfill_at"
         ]);
         const semanticSettings = readSemanticIndexSettingSnapshot(settings, {
@@ -1031,6 +1159,8 @@ export class RecallXRepository {
         }
         return {
             ...semanticStatusSettings,
+            workspaceFallbackEnabled: readBooleanSetting(settings, "search.semantic.workspaceFallback.enabled", false),
+            workspaceFallbackMode: normalizeWorkspaceSemanticFallbackMode(settings["search.semantic.workspaceFallback.mode"]),
             lastBackfillAt: readStringSetting(settings, "search.semantic.last_backfill_at"),
             counts
         };
@@ -1303,6 +1433,7 @@ export class RecallXRepository {
                 const result = this.searchNodesWithFts(input);
                 appendCurrentTelemetryDetails({
                     ftsFallback: false,
+                    lexicalQuality: summarizeLexicalQuality(result.items),
                     resultCount: result.items.length,
                     totalCount: result.total
                 });
@@ -1312,6 +1443,7 @@ export class RecallXRepository {
                 const fallbackResult = this.searchNodesWithLike(input);
                 appendCurrentTelemetryDetails({
                     ftsFallback: true,
+                    lexicalQuality: summarizeLexicalQuality(fallbackResult.items),
                     resultCount: fallbackResult.items.length,
                     totalCount: fallbackResult.total
                 });
@@ -1321,6 +1453,7 @@ export class RecallXRepository {
         const result = this.searchNodesWithLike(input);
         appendCurrentTelemetryDetails({
             ftsFallback: false,
+            lexicalQuality: summarizeLexicalQuality(result.items),
             resultCount: result.items.length,
             totalCount: result.total
         });
@@ -1332,6 +1465,7 @@ export class RecallXRepository {
                 const result = this.searchActivitiesWithFts(input);
                 appendCurrentTelemetryDetails({
                     ftsFallback: false,
+                    lexicalQuality: summarizeLexicalQuality(result.items),
                     resultCount: result.items.length,
                     totalCount: result.total
                 });
@@ -1341,6 +1475,7 @@ export class RecallXRepository {
                 const fallbackResult = this.searchActivitiesWithLike(input);
                 appendCurrentTelemetryDetails({
                     ftsFallback: true,
+                    lexicalQuality: summarizeLexicalQuality(fallbackResult.items),
                     resultCount: fallbackResult.items.length,
                     totalCount: fallbackResult.total
                 });
@@ -1350,6 +1485,7 @@ export class RecallXRepository {
         const result = this.searchActivitiesWithLike(input);
         appendCurrentTelemetryDetails({
             ftsFallback: false,
+            lexicalQuality: summarizeLexicalQuality(result.items),
             resultCount: result.items.length,
             totalCount: result.total
         });
@@ -1465,6 +1601,8 @@ export class RecallXRepository {
         const resolvedActivityResults = fallbackTokens.length >= 2 && includeActivities
             ? this.searchWorkspaceActivityFallback(fallbackTokens, input.activityFilters ?? {}, requestedWindow)
             : activityResults;
+        const bestNodeLexicalQuality = summarizeLexicalQuality(resolvedNodeResults.items);
+        const bestActivityLexicalQuality = summarizeLexicalQuality(resolvedActivityResults.items);
         const merged = this.mergeWorkspaceSearchResults(resolvedNodeResults.items, resolvedActivityResults.items, input.sort);
         const deterministicResult = {
             total: fallbackTokens.length >= 2
@@ -1477,6 +1615,7 @@ export class RecallXRepository {
             semanticFallbackEligible: false,
             semanticFallbackAttempted: false,
             semanticFallbackUsed: false,
+            semanticFallbackMode: includeNodes && semanticSettings.workspaceFallbackEnabled ? semanticSettings.workspaceFallbackMode : null,
             semanticFallbackCandidateCount: 0,
             semanticFallbackResultCount: 0,
             semanticFallbackBackend: null,
@@ -1485,16 +1624,31 @@ export class RecallXRepository {
             semanticFallbackQueryLengthBucket: queryPresent ? bucketSemanticQueryLength(normalizedQuery.length) : null
         };
         const appendWorkspaceSearchTelemetry = (result) => {
+            const nodeItems = result.items.flatMap((item) => item.resultType === "node" && item.node ? [item.node] : []);
+            const activityItems = result.items.flatMap((item) => item.resultType === "activity" && item.activity ? [item.activity] : []);
             appendCurrentTelemetryDetails({
+                searchHit: result.items.length > 0,
                 candidateCount: requestedWindow,
                 nodeCandidateCount: resolvedNodeResults.items.length,
                 activityCandidateCount: resolvedActivityResults.items.length,
+                nodeResultCount: nodeItems.length,
+                activityResultCount: activityItems.length,
+                bestNodeLexicalQuality,
+                bestActivityLexicalQuality,
+                lexicalNodeHit: bestNodeLexicalQuality !== "none",
+                strongNodeLexicalHit: bestNodeLexicalQuality === "strong",
+                resultComposition: computeWorkspaceResultComposition({
+                    nodeCount: nodeItems.length,
+                    activityCount: activityItems.length,
+                    semanticUsed: telemetry.semanticFallbackUsed
+                }),
                 resultCount: result.items.length,
                 totalCount: result.total,
                 fallbackTokenCount: fallbackTokens.length,
                 semanticFallbackEligible: telemetry.semanticFallbackEligible,
                 semanticFallbackAttempted: telemetry.semanticFallbackAttempted,
                 semanticFallbackUsed: telemetry.semanticFallbackUsed,
+                semanticFallbackMode: telemetry.semanticFallbackMode ?? undefined,
                 semanticFallbackCandidateCount: telemetry.semanticFallbackCandidateCount,
                 semanticFallbackResultCount: telemetry.semanticFallbackResultCount,
                 semanticFallbackBackend: telemetry.semanticFallbackBackend,
@@ -1502,13 +1656,18 @@ export class RecallXRepository {
                 semanticFallbackSkippedReason: telemetry.semanticFallbackSkippedReason
             });
         };
+        const strictZeroFallbackBlocked = resolvedNodeResults.total + resolvedActivityResults.total > 0;
+        const noStrongNodeFallbackBlocked = bestNodeLexicalQuality === "strong";
+        const semanticFallbackBlockedByMode = semanticSettings.workspaceFallbackMode === "strict_zero"
+            ? strictZeroFallbackBlocked
+            : noStrongNodeFallbackBlocked;
         const shouldAttemptSemanticFallback = includeNodes &&
             semanticSettings.workspaceFallbackEnabled &&
             queryPresent &&
             normalizedQuery.length >= 6 &&
-            deterministicResult.total === 0 &&
             semanticSettings.enabled &&
-            Boolean(semanticSettings.provider && semanticSettings.model);
+            Boolean(semanticSettings.provider && semanticSettings.model) &&
+            !semanticFallbackBlockedByMode;
         if (!includeNodes) {
             telemetry.semanticFallbackSkippedReason = "nodes_scope_disabled";
         }
@@ -1521,15 +1680,18 @@ export class RecallXRepository {
         else if (!semanticSettings.workspaceFallbackEnabled) {
             telemetry.semanticFallbackSkippedReason = "workspace_fallback_disabled";
         }
-        else if (deterministicResult.total > 0) {
-            telemetry.semanticFallbackSkippedReason = "deterministic_results_present";
-        }
         else if (!semanticSettings.enabled) {
             telemetry.semanticFallbackSkippedReason = "semantic_disabled";
         }
         else if (!semanticSettings.provider || !semanticSettings.model) {
             telemetry.semanticFallbackSkippedReason = "semantic_provider_unconfigured";
         }
+        else if (semanticSettings.workspaceFallbackMode === "strict_zero" && strictZeroFallbackBlocked) {
+            telemetry.semanticFallbackSkippedReason = "strict_zero_results_present";
+        }
+        else if (semanticSettings.workspaceFallbackMode === "no_strong_node_hit" && noStrongNodeFallbackBlocked) {
+            telemetry.semanticFallbackSkippedReason = "strong_node_lexical_present";
+        }
         if (shouldAttemptSemanticFallback) {
             const candidateNodeIds = this.listWorkspaceSemanticFallbackCandidateNodeIds(input.nodeFilters ?? {}, semanticSettings, 200);
             telemetry.semanticFallbackEligible = true;
@@ -1541,8 +1703,7 @@ export class RecallXRepository {
             else {
                 telemetry.semanticFallbackAttempted = true;
                 const runSemanticFallback = async () => {
-                    const semanticMatches = await this.rankSemanticCandidates(normalizedQuery, candidateNodeIds);
-                    const items = this.buildWorkspaceSemanticFallbackNodeItems(candidateNodeIds, semanticMatches, this.getSemanticAugmentationSettings()).map((node) => ({ resultType: "node", node }));
+                    const items = this.buildWorkspaceSemanticFallbackNodeItems(candidateNodeIds, await this.rankSemanticCandidates(normalizedQuery, candidateNodeIds), this.getSemanticAugmentationSettings());
                     return {
                         items,
                         resultCount: items.length
@@ -1554,15 +1715,18 @@ export class RecallXRepository {
                             semanticFallbackCandidateCount: candidateNodeIds.length,
                             semanticFallbackBackend: semanticSettings.indexBackend,
                             semanticFallbackConfiguredBackend: semanticSettings.configuredIndexBackend,
+                            semanticFallbackMode: telemetry.semanticFallbackMode ?? undefined,
                             semanticFallbackQueryLengthBucket: telemetry.semanticFallbackQueryLengthBucket
                         }, runSemanticFallback)
                         : await runSemanticFallback();
                     telemetry.semanticFallbackResultCount = semanticResult.resultCount;
                     if (semanticResult.resultCount > 0) {
                         telemetry.semanticFallbackUsed = true;
+                        const mergedNodeItems = mergeNodeSearchItems(semanticResult.items, resolvedNodeResults.items);
+                        const mergedSemanticItems = this.mergeWorkspaceSearchResults(mergedNodeItems, resolvedActivityResults.items, input.sort);
                         const semanticWorkspaceResult = {
-                            total: semanticResult.resultCount,
-                            items: semanticResult.items
+                            total: mergedNodeItems.length + (includeActivities ? resolvedActivityResults.total : 0),
+                            items: mergedSemanticItems.slice(input.offset, input.offset + input.limit)
                         };
                         appendWorkspaceSearchTelemetry(semanticWorkspaceResult);
                         return {
@@ -1638,6 +1802,8 @@ export class RecallXRepository {
                         timestamp: node.updatedAt,
                         resultType: "node",
                         contested: node.status === "contested",
+                        matchReason: node.matchReason,
+                        lexicalQuality: node.lexicalQuality,
                         nowMs
                     })
                     : 0
@@ -1656,6 +1822,8 @@ export class RecallXRepository {
                         timestamp: activity.createdAt,
                         resultType: "activity",
                         contested: activity.targetNodeStatus === "contested",
+                        matchReason: activity.matchReason,
+                        lexicalQuality: activity.lexicalQuality,
                         nowMs
                     })
                     : 0
@@ -1673,6 +1841,24 @@ export class RecallXRepository {
         }
         return merged.map(({ index: _index, total: _total, timestamp: _timestamp, contested: _contested, smartScore: _smartScore, ...item }) => item);
     }
+    mergeNodeSearchResults(primary, secondary) {
+        const merged = new Map();
+        for (const item of [...primary, ...secondary]) {
+            const current = merged.get(item.id);
+            if (!current) {
+                merged.set(item.id, item);
+                continue;
+            }
+            merged.set(item.id, {
+                ...current,
+                matchReason: current.matchReason?.strategy === "semantic" && item.matchReason
+                    ? item.matchReason
+                    : current.matchReason ?? item.matchReason,
+                lexicalQuality: mergeLexicalQuality(current.lexicalQuality, item.lexicalQuality)
+            });
+        }
+        return Array.from(merged.values());
+    }
     searchNodesWithFts(input) {
         const where = [];
         const values = [];
@@ -1851,23 +2037,31 @@ export class RecallXRepository {
          LIMIT ? OFFSET ?`)
             .all(...whereValues, ...params.orderValues, effectiveLimit, effectiveOffset);
         const matcher = params.strategy === "browse" ? null : createSearchFieldMatcher(params.input.query);
-        const items = rows.map((row) => ({
-            id: String(row.id),
-            targetNodeId: String(row.target_node_id),
-            targetNodeTitle: row.target_title ? String(row.target_title) : null,
-            targetNodeType: row.target_type ? row.target_type : null,
-            targetNodeStatus: row.target_status ? row.target_status : null,
-            activityType: row.activity_type,
-            body: row.body ? String(row.body) : null,
-            sourceLabel: row.source_label ? String(row.source_label) : null,
-            createdAt: String(row.created_at),
-            matchReason: buildSearchMatchReason(params.strategy, collectMatchedFields(matcher, [
+        const items = rows.map((row) => {
+            const signals = collectSearchFieldSignals(matcher, [
                 { field: "body", value: row.body ? String(row.body) : null },
                 { field: "targetNodeTitle", value: row.target_title ? String(row.target_title) : null },
                 { field: "activityType", value: row.activity_type ? String(row.activity_type) : null },
                 { field: "sourceLabel", value: row.source_label ? String(row.source_label) : null }
-            ]))
-        }));
+            ]);
+            const lexicalQuality = classifyActivityLexicalQuality(params.strategy, signals);
+            return {
+                id: String(row.id),
+                targetNodeId: String(row.target_node_id),
+                targetNodeTitle: row.target_title ? String(row.target_title) : null,
+                targetNodeType: row.target_type ? row.target_type : null,
+                targetNodeStatus: row.target_status ? row.target_status : null,
+                activityType: row.activity_type,
+                body: row.body ? String(row.body) : null,
+                sourceLabel: row.source_label ? String(row.source_label) : null,
+                createdAt: String(row.created_at),
+                lexicalQuality,
+                matchReason: buildSearchMatchReason(params.strategy, signals.matchedFields, {
+                    strength: lexicalQuality === "none" ? undefined : lexicalQuality,
+                    termCoverage: signals.totalTermCount > 0 ? Number((signals.matchedTermCount / signals.totalTermCount).toFixed(4)) : null
+                })
+            };
+        });
         const rankedItems = useSearchFeedbackBoost ? this.applyActivitySearchFeedbackBoost(items) : items;
         const cappedItems = this.capActivityResultsPerTarget(rankedItems);
         return {
@@ -1914,6 +2108,14 @@ export class RecallXRepository {
         const matcher = strategy === "browse" ? null : createSearchFieldMatcher(query);
         const items = rows.map((row) => {
             const tags = parseJson(row.tags_json, []);
+            const signals = collectSearchFieldSignals(matcher, [
+                { field: "title", value: row.title ? String(row.title) : null },
+                { field: "summary", value: row.summary ? String(row.summary) : null },
+                { field: "body", value: row.body ? String(row.body) : null },
+                { field: "tags", value: tags.join(" ") },
+                { field: "sourceLabel", value: row.source_label ? String(row.source_label) : null }
+            ]);
+            const lexicalQuality = classifyNodeLexicalQuality(strategy, signals);
             return {
                 id: String(row.id),
                 type: row.type,
@@ -1924,13 +2126,11 @@ export class RecallXRepository {
                 sourceLabel: row.source_label ? String(row.source_label) : null,
                 updatedAt: String(row.updated_at),
                 tags,
-                matchReason: buildSearchMatchReason(strategy, collectMatchedFields(matcher, [
-                    { field: "title", value: row.title ? String(row.title) : null },
-                    { field: "summary", value: row.summary ? String(row.summary) : null },
-                    { field: "body", value: row.body ? String(row.body) : null },
-                    { field: "tags", value: tags.join(" ") },
-                    { field: "sourceLabel", value: row.source_label ? String(row.source_label) : null }
-                ]))
+                lexicalQuality,
+                matchReason: buildSearchMatchReason(strategy, signals.matchedFields, {
+                    strength: lexicalQuality === "none" ? undefined : lexicalQuality,
+                    termCoverage: signals.totalTermCount > 0 ? Number((signals.matchedTermCount / signals.totalTermCount).toFixed(4)) : null
+                })
             };
         });
         const rankedItems = useSearchFeedbackBoost ? this.applySearchFeedbackBoost(items) : items;

package/app/server/workspace-session.js

@@ -76,6 +76,7 @@ export class WorkspaceSessionManager {
             "search.semantic.chunk.enabled": false,
             "search.semantic.chunk.aggregation": "max",
             "search.semantic.workspaceFallback.enabled": false,
+            "search.semantic.workspaceFallback.mode": "strict_zero",
             "search.semantic.augmentation.minSimilarity": 0.2,
             "search.semantic.augmentation.maxBonus": 18,
             "search.semantic.last_backfill_at": null,

package/app/shared/version.js

@@ -1 +1 @@
-export const RECALLX_VERSION = "1.0.0";
+export const RECALLX_VERSION = "1.0.2";