recallx 1.0.0 → 1.0.2

package/README.md

@@ -160,7 +160,7 @@ At `/`, the headless runtime returns a small runtime notice instead of the rende
 
 Node requirements:
 
-- npm packages: Node 20+
+- npm packages: Node 22.13+
 - local source development: Node 25+ is recommended because the backend uses `node:sqlite`
 
 ## Use From Other Coding Agents

package/app/cli/src/cli.js

@@ -726,7 +726,14 @@ function buildMcpConfigPayload(launcherPath) {
 }
 async function installMcpLauncher(launcherPath, commandParts) {
     await mkdir(path.dirname(launcherPath), { recursive: true });
-    await writeFile(launcherPath, `#!/bin/sh\nexec ${commandParts.map(quoteShellArg).join(" ")} "$@"\n`, "utf8");
+    await writeFile(launcherPath, `#!/bin/sh
+NODE_BIN="\${RECALLX_NODE_BIN:-$(command -v node 2>/dev/null || true)}"
+if [ -z "$NODE_BIN" ]; then
+  echo "recallx-mcp launcher could not find a node executable in PATH." >&2
+  exit 1
+fi
+exec "$NODE_BIN" ${commandParts.slice(1).map(quoteShellArg).join(" ")} "$@"
+`, "utf8");
     await chmod(launcherPath, 0o755);
 }
 function quoteShellArg(value) {

package/app/cli/src/format.js

@@ -202,11 +202,65 @@ export function renderTelemetrySummary(data) {
       `fts fallback: ${data.ftsFallbackRate.fallbackCount}/${data.ftsFallbackRate.sampleCount} (${data.ftsFallbackRate.ratio ?? "n/a"})`
     );
   }
+  if (data?.searchHitRate) {
+    lines.push(
+      `search hit rate: ${data.searchHitRate.hitCount}/${data.searchHitRate.sampleCount} (${data.searchHitRate.ratio ?? "n/a"})`
+    );
+    const searchHitOps = Array.isArray(data.searchHitRate.operations) ? data.searchHitRate.operations : [];
+    for (const item of searchHitOps.slice(0, 5)) {
+      lines.push(
+        `- [${item.surface}] ${item.operation}: ${item.hitCount}/${item.sampleCount} hits (${item.ratio ?? "n/a"})`
+      );
+    }
+  }
+  if (data?.searchLexicalQualityRate) {
+    lines.push(
+      `lexical quality: strong=${data.searchLexicalQualityRate.strongCount}, weak=${data.searchLexicalQualityRate.weakCount}, none=${data.searchLexicalQualityRate.noneCount}`
+    );
+  }
+  if (data?.workspaceResultCompositionRate) {
+    lines.push(
+      `workspace composition: node_only=${data.workspaceResultCompositionRate.nodeOnlyCount}, semantic_node_only=${data.workspaceResultCompositionRate.semanticNodeOnlyCount}, activity_only=${data.workspaceResultCompositionRate.activityOnlyCount}, mixed=${data.workspaceResultCompositionRate.mixedCount}, semantic_mixed=${data.workspaceResultCompositionRate.semanticMixedCount}, empty=${data.workspaceResultCompositionRate.emptyCount}`
+    );
+  }
+  if (data?.workspaceFallbackModeRate) {
+    lines.push(
+      `workspace fallback modes: strict_zero=${data.workspaceFallbackModeRate.strictZeroCount}, no_strong_node_hit=${data.workspaceFallbackModeRate.noStrongNodeHitCount}`
+    );
+  }
+  if (data?.searchFeedbackRate) {
+    lines.push(
+      `search feedback: useful=${data.searchFeedbackRate.usefulCount}/${data.searchFeedbackRate.sampleCount} (${data.searchFeedbackRate.usefulRatio ?? "n/a"}), top1=${data.searchFeedbackRate.top1UsefulCount}/${data.searchFeedbackRate.top1SampleCount} (${data.searchFeedbackRate.top1UsefulRatio ?? "n/a"}), top3=${data.searchFeedbackRate.top3UsefulCount}/${data.searchFeedbackRate.top3SampleCount} (${data.searchFeedbackRate.top3UsefulRatio ?? "n/a"}), semantic_fp=${data.searchFeedbackRate.semanticFalsePositiveRatio ?? "n/a"}`
+    );
+    const qualityBuckets = Array.isArray(data.searchFeedbackRate.byLexicalQuality) ? data.searchFeedbackRate.byLexicalQuality : [];
+    for (const item of qualityBuckets) {
+      lines.push(
+        `- feedback [${item.lexicalQuality}]: ${item.usefulCount}/${item.sampleCount} useful (${item.usefulRatio ?? "n/a"})`
+      );
+    }
+    const fallbackModeBuckets = Array.isArray(data.searchFeedbackRate.byFallbackMode) ? data.searchFeedbackRate.byFallbackMode : [];
+    for (const item of fallbackModeBuckets) {
+      lines.push(
+        `- feedback mode [${item.fallbackMode}]: ${item.usefulCount}/${item.sampleCount} useful (${item.usefulRatio ?? "n/a"})`
+      );
+    }
+  }
   if (data?.semanticAugmentationRate) {
     lines.push(
       `semantic augmentation: ${data.semanticAugmentationRate.usedCount}/${data.semanticAugmentationRate.sampleCount} (${data.semanticAugmentationRate.ratio ?? "n/a"})`
     );
   }
+  if (data?.semanticFallbackRate) {
+    lines.push(
+      `semantic fallback: eligible=${data.semanticFallbackRate.eligibleCount}, attempted=${data.semanticFallbackRate.attemptedCount}, hit=${data.semanticFallbackRate.hitCount}, hit_ratio=${data.semanticFallbackRate.hitRatio ?? "n/a"}`
+    );
+    const fallbackModes = Array.isArray(data.semanticFallbackRate.modes) ? data.semanticFallbackRate.modes : [];
+    for (const item of fallbackModes) {
+      lines.push(
+        `- fallback mode [${item.fallbackMode}]: attempted=${item.attemptedCount}/${item.eligibleCount} (${item.attemptRatio ?? "n/a"}), hit=${item.hitCount}/${item.attemptedCount} (${item.hitRatio ?? "n/a"})`
+      );
+    }
+  }
 
   return `${lines.join("\n")}\n`;
 }

package/app/cli/src/http.js

@@ -6,7 +6,7 @@ export function getApiBase(argvOptions = {}, env = process.env) {
         DEFAULT_API_BASE);
 }
 export function getAuthToken(argvOptions = {}, env = process.env) {
-    return argvOptions.token || env.RECALLX_TOKEN || "";
+    return argvOptions.token || env.RECALLX_API_TOKEN || env.RECALLX_TOKEN || "";
 }
 export async function requestJson(apiBase, path, { method = "GET", token, body } = {}) {
     const response = await fetch(buildApiUrl(apiBase, path), buildApiRequestInit({ method, token, body }));

package/app/server/app.js

@@ -8,7 +8,7 @@ import { activitySearchSchema, appendActivitySchema, appendRelationUsageEventSch
 import { AppError } from "./errors.js";
 import { isShortLogLikeAgentNodeInput, maybeCreatePromotionCandidate, recomputeAutomaticGovernance, resolveGovernancePolicy, resolveNodeGovernance, resolveRelationStatus, shouldPromoteActivitySummary } from "./governance.js";
 import { refreshAutomaticInferredRelationsForNode, reindexAutomaticInferredRelations } from "./inferred-relations.js";
-import { createObservabilityWriter, summarizePayloadShape } from "./observability.js";
+import { appendCurrentTelemetryDetails, createObservabilityWriter, summarizePayloadShape } from "./observability.js";
 import { buildSemanticCandidateBonusMap, buildCandidateRelationBonusMap, buildContextBundle, buildNeighborhoodItems, buildTargetRelatedRetrievalItems, bundleAsMarkdown, computeRankCandidateScore, shouldUseSemanticCandidateAugmentation } from "./retrieval.js";
 import { buildProjectGraph } from "./project-graph.js";
 import { createId, isPathWithinRoot } from "./utils.js";
@@ -172,6 +172,9 @@ function parseBooleanSetting(value, fallback) {
 function parseNumberSetting(value, fallback) {
     return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
+function readWorkspaceSemanticFallbackMode(value) {
+    return value === "strict_zero" || value === "no_strong_node_hit" ? value : null;
+}
 function normalizeApiRequestPath(value) {
     return value
         .replace(/^\/artifacts\/.+$/g, "/artifacts/:path")
@@ -1406,6 +1409,12 @@ export function createRecallXApp(params) {
         }, (span) => {
             const searchResult = currentRepository().searchNodes(input);
             span.addDetails({
+                searchHit: searchResult.items.length > 0,
+                bestLexicalQuality: searchResult.items.some((item) => item.lexicalQuality === "strong")
+                    ? "strong"
+                    : searchResult.items.some((item) => item.lexicalQuality === "weak")
+                        ? "weak"
+                        : "none",
                 resultCount: searchResult.items.length,
                 totalCount: searchResult.total
             });
@@ -1423,6 +1432,12 @@ export function createRecallXApp(params) {
         }, (span) => {
             const searchResult = currentRepository().searchActivities(input);
             span.addDetails({
+                searchHit: searchResult.items.length > 0,
+                bestLexicalQuality: searchResult.items.some((item) => item.lexicalQuality === "strong")
+                    ? "strong"
+                    : searchResult.items.some((item) => item.lexicalQuality === "weak")
+                        ? "weak"
+                        : "none",
                 resultCount: searchResult.items.length,
                 totalCount: searchResult.total
             });
@@ -1457,6 +1472,7 @@ export function createRecallXApp(params) {
                 })
             });
             span.addDetails({
+                searchHit: searchResult.items.length > 0,
                 resultCount: searchResult.items.length,
                 totalCount: searchResult.total
             });
@@ -1861,9 +1877,55 @@ export function createRecallXApp(params) {
             governance: buildGovernancePayload(repository, "relation", event.relationId, governanceResult.items[0] ?? repository.getGovernanceStateNullable("relation", event.relationId))
         }));
     });
-    app.post("/api/v1/search-feedback-events", (request, response) => {
+    app.post("/api/v1/search-feedback-events", handleAsyncRoute(async (request, response) => {
         const repository = currentRepository();
         const event = repository.appendSearchFeedbackEvent(appendSearchFeedbackSchema.parse(request.body ?? {}));
+        const metadata = event.metadata ?? {};
+        const fallbackMode = readWorkspaceSemanticFallbackMode(metadata.semanticFallbackMode);
+        const lexicalQuality = metadata.lexicalQuality === "strong" || metadata.lexicalQuality === "weak" || metadata.lexicalQuality === "none"
+            ? metadata.lexicalQuality
+            : null;
+        const feedbackRank = typeof metadata.rank === "number" && Number.isFinite(metadata.rank)
+            ? metadata.rank
+            : typeof metadata.resultRank === "number" && Number.isFinite(metadata.resultRank)
+                ? metadata.resultRank
+                : null;
+        const matchStrategy = metadata.matchStrategy === "fts" ||
+            metadata.matchStrategy === "like" ||
+            metadata.matchStrategy === "fallback_token" ||
+            metadata.matchStrategy === "semantic" ||
+            metadata.matchStrategy === "browse"
+            ? metadata.matchStrategy
+            : null;
+        await observability.recordEvent({
+            surface: "api",
+            operation: "search.feedback",
+            details: {
+                feedbackVerdict: event.verdict,
+                feedbackResultType: event.resultType,
+                feedbackLexicalQuality: lexicalQuality,
+                feedbackConfidence: event.confidence,
+                feedbackRank,
+                feedbackMatchStrategy: matchStrategy,
+                feedbackSemanticLifted: metadata.semanticLifted === true,
+                feedbackSemanticFallbackMode: fallbackMode ?? undefined,
+                feedbackHasQuery: Boolean(event.query?.trim()),
+                feedbackHasRunId: Boolean(event.runId),
+                feedbackHasSessionId: Boolean(event.sessionId)
+            }
+        });
+        appendCurrentTelemetryDetails({
+            feedbackVerdict: event.verdict,
+            feedbackResultType: event.resultType,
+            feedbackLexicalQuality: lexicalQuality,
+            feedbackMatchStrategy: matchStrategy,
+            feedbackRank,
+            feedbackSemanticLifted: metadata.semanticLifted === true,
+            feedbackSemanticFallbackMode: fallbackMode ?? undefined,
+            feedbackHasQuery: Boolean(event.query?.trim()),
+            feedbackHasRunId: Boolean(event.runId),
+            feedbackHasSessionId: Boolean(event.sessionId)
+        });
         const governanceResult = event.resultType === "node"
             ? recomputeGovernanceForEntities("node", [event.resultId])
             : { items: [] };
@@ -1878,7 +1940,7 @@ export function createRecallXApp(params) {
                 ? buildGovernancePayload(repository, "node", event.resultId, governanceResult.items[0] ?? repository.getGovernanceStateNullable("node", event.resultId))
                 : null
         }));
-    });
+    }));
     app.post("/api/v1/inferred-relations/recompute", handleAsyncRoute(async (request, response) => {
         const input = recomputeInferredRelationsSchema.parse(request.body ?? {});
         const isFullMaintenancePass = !input.generator && !input.relationIds?.length;

package/app/server/observability.js

@@ -340,8 +340,44 @@ export class ObservabilityWriter {
         const buckets = new Map();
         const mcpFailures = new Map();
         const autoJobs = new Map();
+        const searchHitBuckets = new Map();
+        const lexicalQualityBuckets = new Map();
+        const workspaceFallbackModeBuckets = new Map();
+        const feedbackByLexicalQuality = new Map();
+        const feedbackByFallbackMode = new Map();
+        const semanticFallbackByMode = new Map();
         let ftsFallbackCount = 0;
         let ftsSampleCount = 0;
+        let searchHitCount = 0;
+        let searchMissCount = 0;
+        let searchSampleCount = 0;
+        let strongLexicalCount = 0;
+        let weakLexicalCount = 0;
+        let noLexicalCount = 0;
+        let lexicalSampleCount = 0;
+        let emptyCompositionCount = 0;
+        let nodeOnlyCompositionCount = 0;
+        let activityOnlyCompositionCount = 0;
+        let mixedCompositionCount = 0;
+        let semanticNodeOnlyCompositionCount = 0;
+        let semanticMixedCompositionCount = 0;
+        let compositionSampleCount = 0;
+        let strictZeroFallbackModeCount = 0;
+        let noStrongNodeHitFallbackModeCount = 0;
+        let workspaceFallbackModeSampleCount = 0;
+        let feedbackUsefulCount = 0;
+        let feedbackNotUsefulCount = 0;
+        let feedbackUncertainCount = 0;
+        let feedbackSampleCount = 0;
+        let feedbackTop1UsefulCount = 0;
+        let feedbackTop1SampleCount = 0;
+        let feedbackTop3UsefulCount = 0;
+        let feedbackTop3SampleCount = 0;
+        let feedbackSemanticUsefulCount = 0;
+        let feedbackSemanticNotUsefulCount = 0;
+        let feedbackSemanticSampleCount = 0;
+        let feedbackSemanticLiftUsefulCount = 0;
+        let feedbackSemanticLiftSampleCount = 0;
         let semanticUsedCount = 0;
         let semanticSampleCount = 0;
         let semanticFallbackEligibleCount = 0;
@@ -354,6 +390,209 @@ export class ObservabilityWriter {
                     ftsFallbackCount += 1;
                 }
             }
+            if (typeof event.details.searchHit === "boolean") {
+                searchSampleCount += 1;
+                if (event.details.searchHit) {
+                    searchHitCount += 1;
+                }
+                else {
+                    searchMissCount += 1;
+                }
+                const bucketKey = `${event.surface}:${event.operation}`;
+                const current = searchHitBuckets.get(bucketKey) ?? {
+                    surface: event.surface,
+                    operation: event.operation,
+                    hitCount: 0,
+                    missCount: 0
+                };
+                if (event.details.searchHit) {
+                    current.hitCount += 1;
+                }
+                else {
+                    current.missCount += 1;
+                }
+                searchHitBuckets.set(bucketKey, current);
+            }
+            if (event.details.bestLexicalQuality === "strong" ||
+                event.details.bestLexicalQuality === "weak" ||
+                event.details.bestLexicalQuality === "none" ||
+                event.details.bestNodeLexicalQuality === "strong" ||
+                event.details.bestNodeLexicalQuality === "weak" ||
+                event.details.bestNodeLexicalQuality === "none") {
+                const quality = (event.details.bestNodeLexicalQuality ??
+                    event.details.bestLexicalQuality);
+                lexicalSampleCount += 1;
+                if (quality === "strong") {
+                    strongLexicalCount += 1;
+                }
+                else if (quality === "weak") {
+                    weakLexicalCount += 1;
+                }
+                else {
+                    noLexicalCount += 1;
+                }
+                const bucketKey = `${event.surface}:${event.operation}`;
+                const current = lexicalQualityBuckets.get(bucketKey) ?? {
+                    surface: event.surface,
+                    operation: event.operation,
+                    strongCount: 0,
+                    weakCount: 0,
+                    noneCount: 0
+                };
+                if (quality === "strong") {
+                    current.strongCount += 1;
+                }
+                else if (quality === "weak") {
+                    current.weakCount += 1;
+                }
+                else {
+                    current.noneCount += 1;
+                }
+                lexicalQualityBuckets.set(bucketKey, current);
+            }
+            if (typeof event.details.resultComposition === "string") {
+                compositionSampleCount += 1;
+                switch (event.details.resultComposition) {
+                    case "node_only":
+                        nodeOnlyCompositionCount += 1;
+                        break;
+                    case "activity_only":
+                        activityOnlyCompositionCount += 1;
+                        break;
+                    case "mixed":
+                        mixedCompositionCount += 1;
+                        break;
+                    case "semantic_node_only":
+                        semanticNodeOnlyCompositionCount += 1;
+                        break;
+                    case "semantic_mixed":
+                        semanticMixedCompositionCount += 1;
+                        break;
+                    default:
+                        emptyCompositionCount += 1;
+                        break;
+                }
+            }
+            if (event.operation === "workspace.search" &&
+                (event.details.semanticFallbackMode === "strict_zero" || event.details.semanticFallbackMode === "no_strong_node_hit")) {
+                workspaceFallbackModeSampleCount += 1;
+                if (event.details.semanticFallbackMode === "strict_zero") {
+                    strictZeroFallbackModeCount += 1;
+                }
+                else {
+                    noStrongNodeHitFallbackModeCount += 1;
+                }
+                const bucketKey = `${event.surface}:${event.operation}`;
+                const current = workspaceFallbackModeBuckets.get(bucketKey) ?? {
+                    surface: event.surface,
+                    operation: event.operation,
+                    strictZeroCount: 0,
+                    noStrongNodeHitCount: 0
+                };
+                if (event.details.semanticFallbackMode === "strict_zero") {
+                    current.strictZeroCount += 1;
+                }
+                else {
+                    current.noStrongNodeHitCount += 1;
+                }
+                workspaceFallbackModeBuckets.set(bucketKey, current);
+            }
+            if (event.details.feedbackVerdict === "useful" ||
+                event.details.feedbackVerdict === "not_useful" ||
+                event.details.feedbackVerdict === "uncertain") {
+                feedbackSampleCount += 1;
+                if (event.details.feedbackVerdict === "useful") {
+                    feedbackUsefulCount += 1;
+                }
+                else if (event.details.feedbackVerdict === "not_useful") {
+                    feedbackNotUsefulCount += 1;
+                }
+                else {
+                    feedbackUncertainCount += 1;
+                }
+                const feedbackRank = typeof event.details.feedbackRank === "number" && Number.isFinite(event.details.feedbackRank)
+                    ? event.details.feedbackRank
+                    : null;
+                if (feedbackRank != null) {
+                    if (feedbackRank <= 1) {
+                        feedbackTop1SampleCount += 1;
+                        if (event.details.feedbackVerdict === "useful") {
+                            feedbackTop1UsefulCount += 1;
+                        }
+                    }
+                    if (feedbackRank <= 3) {
+                        feedbackTop3SampleCount += 1;
+                        if (event.details.feedbackVerdict === "useful") {
+                            feedbackTop3UsefulCount += 1;
+                        }
+                    }
+                }
+                const feedbackMatchStrategy = event.details.feedbackMatchStrategy === "fts" ||
+                    event.details.feedbackMatchStrategy === "like" ||
+                    event.details.feedbackMatchStrategy === "fallback_token" ||
+                    event.details.feedbackMatchStrategy === "semantic" ||
+                    event.details.feedbackMatchStrategy === "browse"
+                    ? event.details.feedbackMatchStrategy
+                    : null;
+                if (feedbackMatchStrategy === "semantic") {
+                    feedbackSemanticSampleCount += 1;
+                    if (event.details.feedbackVerdict === "useful") {
+                        feedbackSemanticUsefulCount += 1;
+                    }
+                    else if (event.details.feedbackVerdict === "not_useful") {
+                        feedbackSemanticNotUsefulCount += 1;
+                    }
+                }
+                if (event.details.feedbackSemanticLifted === true) {
+                    feedbackSemanticLiftSampleCount += 1;
+                    if (event.details.feedbackVerdict === "useful") {
+                        feedbackSemanticLiftUsefulCount += 1;
+                    }
+                }
+                const lexicalQuality = event.details.feedbackLexicalQuality === "strong" ||
+                    event.details.feedbackLexicalQuality === "weak" ||
+                    event.details.feedbackLexicalQuality === "none"
+                    ? event.details.feedbackLexicalQuality
+                    : null;
+                if (lexicalQuality) {
+                    const current = feedbackByLexicalQuality.get(lexicalQuality) ?? {
+                        usefulCount: 0,
+                        notUsefulCount: 0,
+                        uncertainCount: 0
+                    };
+                    if (event.details.feedbackVerdict === "useful") {
+                        current.usefulCount += 1;
+                    }
+                    else if (event.details.feedbackVerdict === "not_useful") {
+                        current.notUsefulCount += 1;
+                    }
+                    else {
+                        current.uncertainCount += 1;
+                    }
+                    feedbackByLexicalQuality.set(lexicalQuality, current);
+                }
+                const feedbackFallbackMode = event.details.feedbackSemanticFallbackMode === "strict_zero" ||
+                    event.details.feedbackSemanticFallbackMode === "no_strong_node_hit"
+                    ? event.details.feedbackSemanticFallbackMode
+                    : null;
+                if (feedbackFallbackMode) {
+                    const current = feedbackByFallbackMode.get(feedbackFallbackMode) ?? {
+                        usefulCount: 0,
+                        notUsefulCount: 0,
+                        uncertainCount: 0
+                    };
+                    if (event.details.feedbackVerdict === "useful") {
+                        current.usefulCount += 1;
+                    }
+                    else if (event.details.feedbackVerdict === "not_useful") {
+                        current.notUsefulCount += 1;
+                    }
+                    else {
+                        current.uncertainCount += 1;
+                    }
+                    feedbackByFallbackMode.set(feedbackFallbackMode, current);
+                }
+            }
             if (typeof event.details.semanticUsed === "boolean") {
                 semanticSampleCount += 1;
                 if (event.details.semanticUsed) {
@@ -375,6 +614,29 @@ export class ObservabilityWriter {
                     semanticFallbackHitCount += 1;
                 }
             }
+            const semanticFallbackMode = event.operation === "workspace.search" &&
+                (event.details.semanticFallbackMode === "strict_zero" || event.details.semanticFallbackMode === "no_strong_node_hit")
+                ? event.details.semanticFallbackMode
+                : null;
+            if (semanticFallbackMode) {
+                const current = semanticFallbackByMode.get(semanticFallbackMode) ?? {
+                    eligibleCount: 0,
+                    attemptedCount: 0,
+                    hitCount: 0,
+                    sampleCount: 0
+                };
+                current.sampleCount += 1;
+                if (event.details.semanticFallbackEligible === true) {
+                    current.eligibleCount += 1;
+                }
+                if (event.details.semanticFallbackAttempted === true) {
+                    current.attemptedCount += 1;
+                }
+                if (event.details.semanticFallbackUsed === true) {
+                    current.hitCount += 1;
+                }
+                semanticFallbackByMode.set(semanticFallbackMode, current);
+            }
             if (event.durationMs != null) {
                 const bucketKey = `${event.surface}:${event.operation}`;
                 const current = buckets.get(bucketKey) ??
@@ -440,6 +702,108 @@ export class ObservabilityWriter {
                 sampleCount: ftsSampleCount,
                 ratio: ftsSampleCount > 0 ? Number((ftsFallbackCount / ftsSampleCount).toFixed(4)) : null
             },
+            searchHitRate: {
+                hitCount: searchHitCount,
+                missCount: searchMissCount,
+                sampleCount: searchSampleCount,
+                ratio: searchSampleCount > 0 ? Number((searchHitCount / searchSampleCount).toFixed(4)) : null,
+                operations: [...searchHitBuckets.values()]
+                    .map((item) => ({
+                    ...item,
+                    sampleCount: item.hitCount + item.missCount,
+                    ratio: item.hitCount + item.missCount > 0
+                        ? Number((item.hitCount / (item.hitCount + item.missCount)).toFixed(4))
+                        : null
+                }))
+                    .sort((left, right) => right.sampleCount - left.sampleCount || left.operation.localeCompare(right.operation))
+            },
+            searchLexicalQualityRate: {
+                strongCount: strongLexicalCount,
+                weakCount: weakLexicalCount,
+                noneCount: noLexicalCount,
+                sampleCount: lexicalSampleCount,
+                operations: [...lexicalQualityBuckets.values()]
+                    .map((item) => ({
+                    ...item,
+                    sampleCount: item.strongCount + item.weakCount + item.noneCount
+                }))
+                    .sort((left, right) => right.sampleCount - left.sampleCount || left.operation.localeCompare(right.operation))
+            },
+            workspaceResultCompositionRate: {
+                emptyCount: emptyCompositionCount,
+                nodeOnlyCount: nodeOnlyCompositionCount,
+                activityOnlyCount: activityOnlyCompositionCount,
+                mixedCount: mixedCompositionCount,
+                semanticNodeOnlyCount: semanticNodeOnlyCompositionCount,
+                semanticMixedCount: semanticMixedCompositionCount,
+                sampleCount: compositionSampleCount
+            },
+            workspaceFallbackModeRate: {
+                strictZeroCount: strictZeroFallbackModeCount,
+                noStrongNodeHitCount: noStrongNodeHitFallbackModeCount,
+                sampleCount: workspaceFallbackModeSampleCount,
+                operations: [...workspaceFallbackModeBuckets.values()]
+                    .map((item) => ({
+                    ...item,
+                    sampleCount: item.strictZeroCount + item.noStrongNodeHitCount
+                }))
+                    .sort((left, right) => right.sampleCount - left.sampleCount || left.operation.localeCompare(right.operation))
+            },
+            searchFeedbackRate: {
+                usefulCount: feedbackUsefulCount,
+                notUsefulCount: feedbackNotUsefulCount,
+                uncertainCount: feedbackUncertainCount,
+                sampleCount: feedbackSampleCount,
+                usefulRatio: feedbackSampleCount > 0 ? Number((feedbackUsefulCount / feedbackSampleCount).toFixed(4)) : null,
+                top1UsefulCount: feedbackTop1UsefulCount,
+                top1SampleCount: feedbackTop1SampleCount,
+                top1UsefulRatio: feedbackTop1SampleCount > 0 ? Number((feedbackTop1UsefulCount / feedbackTop1SampleCount).toFixed(4)) : null,
+                top3UsefulCount: feedbackTop3UsefulCount,
+                top3SampleCount: feedbackTop3SampleCount,
+                top3UsefulRatio: feedbackTop3SampleCount > 0 ? Number((feedbackTop3UsefulCount / feedbackTop3SampleCount).toFixed(4)) : null,
+                semanticUsefulCount: feedbackSemanticUsefulCount,
+                semanticNotUsefulCount: feedbackSemanticNotUsefulCount,
+                semanticSampleCount: feedbackSemanticSampleCount,
+                semanticUsefulRatio: feedbackSemanticSampleCount > 0 ? Number((feedbackSemanticUsefulCount / feedbackSemanticSampleCount).toFixed(4)) : null,
+                semanticFalsePositiveRatio: feedbackSemanticSampleCount > 0 ? Number((feedbackSemanticNotUsefulCount / feedbackSemanticSampleCount).toFixed(4)) : null,
+                semanticLiftUsefulCount: feedbackSemanticLiftUsefulCount,
+                semanticLiftSampleCount: feedbackSemanticLiftSampleCount,
+                semanticLiftUsefulRatio: feedbackSemanticLiftSampleCount > 0
+                    ? Number((feedbackSemanticLiftUsefulCount / feedbackSemanticLiftSampleCount).toFixed(4))
+                    : null,
+                byLexicalQuality: ["strong", "weak", "none"]
+                    .map((lexicalQuality) => {
+                    const counts = feedbackByLexicalQuality.get(lexicalQuality) ?? {
+                        usefulCount: 0,
+                        notUsefulCount: 0,
+                        uncertainCount: 0
+                    };
+                    const sampleCount = counts.usefulCount + counts.notUsefulCount + counts.uncertainCount;
+                    return {
+                        lexicalQuality,
+                        ...counts,
+                        sampleCount,
+                        usefulRatio: sampleCount > 0 ? Number((counts.usefulCount / sampleCount).toFixed(4)) : null
+                    };
+                })
+                    .filter((item) => item.sampleCount > 0),
+                byFallbackMode: ["strict_zero", "no_strong_node_hit"]
+                    .map((fallbackMode) => {
+                    const counts = feedbackByFallbackMode.get(fallbackMode) ?? {
+                        usefulCount: 0,
+                        notUsefulCount: 0,
+                        uncertainCount: 0
+                    };
+                    const sampleCount = counts.usefulCount + counts.notUsefulCount + counts.uncertainCount;
+                    return {
+                        fallbackMode,
+                        ...counts,
+                        sampleCount,
+                        usefulRatio: sampleCount > 0 ? Number((counts.usefulCount / sampleCount).toFixed(4)) : null
+                    };
+                })
+                    .filter((item) => item.sampleCount > 0)
+            },
             semanticAugmentationRate: {
                 usedCount: semanticUsedCount,
                 sampleCount: semanticSampleCount,
@@ -454,7 +818,23 @@ export class ObservabilityWriter {
                     : null,
                 hitRatio: semanticFallbackAttemptedCount > 0
                     ? Number((semanticFallbackHitCount / semanticFallbackAttemptedCount).toFixed(4))
-                    : null
+                    : null,
+                modes: ["strict_zero", "no_strong_node_hit"]
+                    .map((fallbackMode) => {
+                    const counts = semanticFallbackByMode.get(fallbackMode) ?? {
+                        eligibleCount: 0,
+                        attemptedCount: 0,
+                        hitCount: 0,
+                        sampleCount: 0
+                    };
+                    return {
+                        fallbackMode,
+                        ...counts,
+                        attemptRatio: counts.eligibleCount > 0 ? Number((counts.attemptedCount / counts.eligibleCount).toFixed(4)) : null,
+                        hitRatio: counts.attemptedCount > 0 ? Number((counts.hitCount / counts.attemptedCount).toFixed(4)) : null
+                    };
+                })
+                    .filter((item) => item.sampleCount > 0)
             },
             autoJobStats: [...autoJobs.entries()].map(([operation, durations]) => ({
                 operation,