@zokizuan/satori-mcp 6.1.0 → 6.3.0

package/README.md

@@ -7,12 +7,18 @@ Most users should install Satori through `@zokizuan/satori-cli`. The installer w
 ## Install
 
 ```bash
-npx -y @zokizuan/satori-cli@latest install --client all --runtime offline
-npx -y @zokizuan/satori-cli@latest doctor
+npm install -g @zokizuan/satori-cli@latest
+satori install --client all
+satori doctor
 ```
 
 The local Potion runtime currently supports Linux x64, including Windows through WSL2. Connected Voyage and explicit local Ollama configurations are also available. See the [main README](https://github.com/ham-zax/satori#quick-start) for runtime choices.
 
+When installed through the CLI, compatible offline Potion + LanceDB clients
+share one private local host, provider/LanceDB state, and one Potion worker. Each
+client remains an independent MCP session. Direct `npx @zokizuan/satori-mcp`
+execution is still isolated and does not join the managed host.
+
 Direct package execution is intended for inspection and custom harnesses:
 
 ```bash
@@ -64,6 +70,9 @@ In a fresh two-task OpenCode comparison where both arms answered correctly, Sato
 - Inbound call-graph evidence is advisory and should be verified before blast-radius edits.
 - Provider, model, dimensions, projection, and vector backend are persisted compatibility identities; changing them requires a reindex.
 - Multiple incompatible live Satori runtimes are blocked from mutating the same publication.
+- Managed offline Potion + LanceDB clients on Linux x64/WSL2 share one private
+  local host. Connected providers, Milvus, and explicit Ollama runtimes keep
+  the direct per-client lifecycle.
 - Offline neural reranking is not shipped today. The candidate boundary permits a future complete-set local scorer to fail back atomically to exact + BM25 + single-vector ordering.
 
 ## Development

package/dist/core/backend-diagnostics.d.ts

@@ -1,3 +1,4 @@
+import type { EmbeddingProviderErrorCode } from "@zokizuan/satori-core";
 export type VectorBackendDiagnosticCode = "ZILLIZ_CLUSTER_STOPPED" | "VECTOR_BACKEND_AUTH_FAILED" | "VECTOR_BACKEND_UNREACHABLE" | "VECTOR_BACKEND_TIMEOUT" | "VECTOR_BACKEND_CONNECTION_CLOSED";
 export interface VectorBackendDiagnostic {
     code: VectorBackendDiagnosticCode;
@@ -11,5 +12,21 @@ export interface VectorBackendDiagnostic {
         };
     };
 }
+export type SemanticPassFailureDiagnostic = {
+    passId: "primary" | "expanded";
+    errorName: "Error" | "TypeError" | "RangeError" | "ReferenceError" | "SyntaxError" | "AggregateError" | "EmbeddingProviderError" | "NonErrorThrow";
+    code: VectorBackendDiagnosticCode | EmbeddingProviderErrorCode | "UNCLASSIFIED_SEARCH_PASS_FAILURE";
+    classifier: "embedding_provider" | "vector_backend" | "unclassified";
+    retryable?: boolean;
+};
+export declare function buildSemanticPassFailureDiagnostic(input: {
+    passId: SemanticPassFailureDiagnostic["passId"];
+    error: unknown;
+    embeddingDiagnostic: {
+        code: EmbeddingProviderErrorCode;
+        retryable: boolean;
+    } | null;
+    vectorDiagnostic: VectorBackendDiagnostic | null;
+}): SemanticPassFailureDiagnostic;
 export declare function classifyVectorBackendError(error: unknown): VectorBackendDiagnostic | null;
 //# sourceMappingURL=backend-diagnostics.d.ts.map

package/dist/core/backend-diagnostics.js

@@ -1,3 +1,47 @@
+const ALLOWED_SEARCH_PASS_ERROR_NAMES = new Set([
+    "Error",
+    "TypeError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "AggregateError",
+    "EmbeddingProviderError",
+]);
+function classifySearchPassErrorName(error) {
+    if (!(error instanceof Error)) {
+        return "NonErrorThrow";
+    }
+    return ALLOWED_SEARCH_PASS_ERROR_NAMES.has(error.name)
+        ? error.name
+        : "Error";
+}
+export function buildSemanticPassFailureDiagnostic(input) {
+    const errorName = classifySearchPassErrorName(input.error);
+    if (input.embeddingDiagnostic) {
+        return {
+            passId: input.passId,
+            errorName,
+            code: input.embeddingDiagnostic.code,
+            classifier: "embedding_provider",
+            retryable: input.embeddingDiagnostic.retryable,
+        };
+    }
+    if (input.vectorDiagnostic) {
+        return {
+            passId: input.passId,
+            errorName,
+            code: input.vectorDiagnostic.code,
+            classifier: "vector_backend",
+            retryable: input.vectorDiagnostic.hints.backend.retryable,
+        };
+    }
+    return {
+        passId: input.passId,
+        errorName,
+        code: "UNCLASSIFIED_SEARCH_PASS_FAILURE",
+        classifier: "unclassified",
+    };
+}
 function collectErrorText(value, depth = 0) {
     if (depth > 2 || value == null) {
         return "";

package/dist/core/call-graph.d.ts

@@ -84,6 +84,7 @@ export type CallGraphQueryResponse = CallGraphResponseSupported | CallGraphRespo
 export interface CallGraphDeltaPolicy {
     shouldRebuild(changedFiles: string[]): boolean;
 }
+export declare const DEFAULT_CALL_GRAPH_TEST_REFERENCE_LIMIT = 50;
 export declare class SupportedSourceDeltaPolicy implements CallGraphDeltaPolicy {
     shouldRebuild(changedFiles: string[]): boolean;
 }

package/dist/core/call-graph.js

@@ -9,7 +9,7 @@ const QUERY_SUPPORTED_EXTENSIONS = new Set(getSupportedExtensionsForCapability('
 const QUERY_SUPPORTED_LANGUAGE_IDS = getSupportedLanguageIdsForCapability('callGraphQuery');
 const DEFAULT_IGNORE_PATTERNS = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/coverage/**', '**/.next/**'];
 const DEFAULT_CALL_GRAPH_NOTE_LIMIT = 200;
-const DEFAULT_CALL_GRAPH_TEST_REFERENCE_LIMIT = 50;
+export const DEFAULT_CALL_GRAPH_TEST_REFERENCE_LIMIT = 50;
 const CALL_KEYWORDS = new Set([
     'if', 'for', 'while', 'switch', 'catch', 'return', 'new', 'typeof', 'function', 'class', 'def', 'await', 'with', 'from', 'import',
 ]);

package/dist/core/canonical-symbol-identity.js

@@ -8,6 +8,25 @@ export function buildCanonicalSymbolRegistryView(symbols) {
     }
     return symbolsByKey;
 }
+function spanContains(parent, child) {
+    if (parent.file !== child.file) {
+        return false;
+    }
+    if (parent.span.startByte !== undefined
+        && parent.span.endByte !== undefined
+        && child.span.startByte !== undefined
+        && child.span.endByte !== undefined) {
+        return parent.span.startByte <= child.span.startByte
+            && child.span.endByte <= parent.span.endByte;
+    }
+    return parent.span.startLine <= child.span.startLine
+        && child.span.endLine <= parent.span.endLine;
+}
+function spanSize(symbol, useBytes) {
+    return useBytes
+        ? Math.max(0, symbol.span.endByte - symbol.span.startByte)
+        : Math.max(0, symbol.span.endLine - symbol.span.startLine);
+}
 function resolveParent(input) {
     const { symbol } = input;
     if (!symbol.parentKey) {
@@ -17,17 +36,26 @@ function resolveParent(input) {
                 : "missing",
         };
     }
-    const candidates = (input.registry.get(symbol.parentKey) || [])
-        .filter((candidate) => candidate.symbolInstanceId !== symbol.symbolInstanceId);
-    if (candidates.length === 0) {
+    const containingCandidates = (input.registry.get(symbol.parentKey) || [])
+        .filter((candidate) => (candidate.symbolInstanceId !== symbol.symbolInstanceId
+        && spanContains(candidate, symbol)));
+    if (containingCandidates.length === 0) {
         return { state: "missing" };
     }
-    if (candidates.length > 1) {
+    const byteCandidates = containingCandidates.filter((candidate) => (candidate.span.startByte !== undefined
+        && candidate.span.endByte !== undefined
+        && symbol.span.startByte !== undefined
+        && symbol.span.endByte !== undefined));
+    const candidates = byteCandidates.length > 0 ? byteCandidates : containingCandidates;
+    const useBytes = byteCandidates.length > 0;
+    const innermostSize = Math.min(...candidates.map((candidate) => spanSize(candidate, useBytes)));
+    const innermost = candidates.filter((candidate) => spanSize(candidate, useBytes) === innermostSize);
+    if (innermost.length !== 1) {
         return { state: "ambiguous" };
     }
     return {
         state: "resolved",
-        parentSymbolId: candidates[0].symbolInstanceId,
+        parentSymbolId: innermost[0].symbolInstanceId,
     };
 }
 export function projectCanonicalSymbolIdentity(input) {

package/dist/core/handlers.d.ts

@@ -296,6 +296,7 @@ export declare class ToolHandlers {
                 searchPassCount: number;
                 searchPassSuccessCount: number;
                 searchPassFailureCount: number;
+                semanticPassFailures?: import("./backend-diagnostics.js").SemanticPassFailureDiagnostic[];
                 rerankerAttempted: boolean;
                 rerankerUsed: boolean;
                 tool?: undefined;
@@ -336,6 +337,7 @@ export declare class ToolHandlers {
                 searchPassCount: number;
                 searchPassSuccessCount: number;
                 searchPassFailureCount: number;
+                semanticPassFailures?: import("./backend-diagnostics.js").SemanticPassFailureDiagnostic[];
                 rerankerAttempted: boolean;
                 rerankerUsed: boolean;
                 tool?: undefined;

package/dist/core/handlers.js

@@ -2298,6 +2298,21 @@ export class ToolHandlers {
                 isError: true,
             };
         }
+        const parsedOperators = this.searchQuerySupport.parseSearchOperators(input.query);
+        if (parsedOperators.semanticQuery.trim().length === 0) {
+            const payload = this.buildInvalidSearchRequestPayload({
+                path: input.path,
+                query: input.query,
+                scope: input.scope,
+                groupBy: input.groupBy,
+                resultMode: input.resultMode,
+                limit: input.limit,
+            }, 'Operator-only search requires semantic text or a positive must:, path:, or lang: value.');
+            return {
+                content: [{ type: "text", text: this.stringifyToolJson(payload) }],
+                isError: true,
+            };
+        }
         const searchDiagnostics = {
             queryLength: input.query.length,
             limitRequested: input.limit,
@@ -2425,9 +2440,16 @@ export class ToolHandlers {
                             thresholdMs: SEARCH_FRESHNESS_THRESHOLD_MS,
                         });
                     }
-                    return this.syncManager.ensureFreshness(effectiveRoot, exactSourceComparisonRequired ? 0 : SEARCH_FRESHNESS_THRESHOLD_MS, preparedRead?.vectorReceipt
-                        ? { preparedVectorReceipt: preparedRead.vectorReceipt }
-                        : {});
+                    return this.syncManager.ensureFreshness(effectiveRoot, exactSourceComparisonRequired ? 0 : SEARCH_FRESHNESS_THRESHOLD_MS, {
+                        ...(preparedRead?.vectorReceipt
+                            ? { preparedVectorReceipt: preparedRead.vectorReceipt }
+                            : {}),
+                        ...(exactSourceComparisonRequired
+                            ? {
+                                exactSourceComparisonPaths: Array.from(changedFilesState.files).sort(),
+                            }
+                            : {}),
+                    });
                 }),
                 noteFreshnessMode: (mode) => {
                     searchDiagnostics.freshnessMode = mode;
@@ -2470,7 +2492,8 @@ export class ToolHandlers {
                 }
             }
             const sourceFreshnessWasEstablished = freshnessDecision.mode === 'synced'
-                || freshnessDecision.mode === 'reconciled_ignore_change';
+                || freshnessDecision.mode === 'reconciled_ignore_change'
+                || freshnessDecision.mode === 'skipped_source_unchanged';
             const checkpointWarningAlreadyPresent = frontDoorWarnings.includes(WARNING_CODES.SOURCE_FRESHNESS_CHECKPOINT_UNAVAILABLE);
             const partialIndexSearchWarnings = !sourceFreshnessWasEstablished
                 && !checkpointWarningAlreadyPresent
@@ -2487,7 +2510,6 @@ export class ToolHandlers {
             console.log(`${rootTag} Query metadata: length=${input.query.length}, requestId=${requestId}`);
             console.log(`${rootTag} Indexing status: Completed`);
             console.log(`${rootTag} 🧠 Using embedding provider: ${encoderEngine.getProvider()} for search`);
-            const parsedOperators = this.searchQuerySupport.parseSearchOperators(input.query);
             const semanticQuery = parsedOperators.semanticQuery;
             const queryPlan = this.searchQuerySupport.buildSearchQueryPlan(semanticQuery, parsedOperators);
             searchDiagnostics.routeKind = queryPlan.route.kind;
@@ -2537,6 +2559,7 @@ export class ToolHandlers {
             const initialDirtyFilesNotFreshened = initialObservedChangedFilesState.available
                 && initialObservedChangedFilesCount > 0
                 && freshnessDecision.mode !== 'synced'
+                && freshnessDecision.mode !== 'skipped_source_unchanged'
                 && freshnessDecision.mode !== 'reconciled_ignore_change';
             const initialRankingProvenance = {
                 semanticPassesUsed: [],
@@ -2755,6 +2778,14 @@ export class ToolHandlers {
                     resultMode: input.resultMode,
                     limit: input.limit
                 }, "Search backend failed: all semantic search passes failed. Retry and verify embedding/vector backends are reachable.", "not_ready", "search_backend_failed");
+                if (debugMode === 'full') {
+                    payload.hints = {
+                        ...(payload.hints || {}),
+                        debugSearch: {
+                            semanticPassFailures: execution.semanticPassFailures.map((failure) => ({ ...failure })),
+                        },
+                    };
+                }
                 return {
                     content: [{ type: "text", text: this.stringifyToolJson(payload) }],
                     isError: true,
@@ -3025,7 +3056,7 @@ export class ToolHandlers {
             includeSummary: true,
             buildEnvelope: (results, disclosure) => {
                 const recommendedNextAction = entry.recommendedActions[lookup.nextOffset] ?? null;
-                const noiseMitigationHint = this.searchQuerySupport.buildNoiseMitigationHint(entry.canonicalRoot, results.map((result) => result.target.file), entry.baseEnvelope.scope);
+                const noiseMitigationHint = this.searchQuerySupport.buildNoiseMitigationHint(entry.canonicalRoot, results.map((result) => result.target.file), entry.baseEnvelope.scope, this.searchQuerySupport.parseSearchOperators(entry.baseEnvelope.query));
                 const generatedArtifactsHint = this.buildGeneratedArtifactsVerificationHint(entry.canonicalRoot, results.map((result) => ({
                     file: result.target.file,
                     span: result.target.span,

package/dist/core/manage-indexing-handlers.js

@@ -766,6 +766,11 @@ export class ManageIndexingHandlers {
                         }
                         this.host.mutationLeaseCoordinator.publishWhileCurrent(mutationLease, publish);
                     },
+                    publicationAuthority: {
+                        ownerId: mutationLease.ownerId,
+                        generation: mutationLease.generation,
+                        operationId: mutationLease.operationId,
+                    },
                 } : {}),
             });
             if (mutationLease) {
@@ -781,16 +786,41 @@ export class ManageIndexingHandlers {
                     ...result.proof,
                     navigation: {
                         status: "unproven",
-                        basis: "call_graph_rebuild_in_progress",
+                        basis: "generation_proof_in_progress",
                     },
                 };
-                await this.host.rebuildCallGraphForIndex(absolutePath, assertMutationCurrent);
+                const proven = await this.host.context.proveIndexedGeneration(absolutePath);
+                if (!proven
+                    || proven.collectionName !== result.collectionName
+                    || proven.marker.indexedFiles !== result.indexedFiles
+                    || proven.exactPayloadCount !== result.totalChunks) {
+                    throw new Error(`Repair completion for '${absolutePath}' did not match an exact proven generation.`);
+                }
+                if (result.activatedGeneration) {
+                    const activated = result.activatedGeneration;
+                    if (activated.collectionName !== proven.collectionName
+                        || activated.markerRunId !== proven.marker.runId
+                        || activated.relationshipVersion !== this.host.runtimeFingerprint.relationshipVersion
+                        || activated.navigation.generationId !== proven.navigation.generationId
+                        || activated.navigation.sealHash !== proven.navigation.navigationSealHash
+                        || activated.navigation.symbolRegistryManifestHash
+                            !== proven.navigation.symbolRegistryManifestHash
+                        || activated.navigation.relationshipManifestHash
+                            !== proven.navigation.relationshipManifestHash) {
+                        throw new Error(`Relationship-only repair for '${absolutePath}' did not prove its activated navigation generation.`);
+                    }
+                    const checkpoint = await this.host.context.inspectSourceFreshnessCheckpoint(absolutePath, proven.collectionName, proven);
+                    if (checkpoint.status !== "valid"
+                        || checkpoint.documentDigest !== activated.sourceCheckpointDocumentDigest) {
+                        throw new Error(`Relationship-only repair for '${absolutePath}' did not preserve its source checkpoint identity.`);
+                    }
+                }
                 assertMutationCurrent?.();
                 lastRepairProof = {
                     ...result.proof,
                     navigation: {
                         status: "matched",
-                        basis: "navigation_and_call_graph_rebuilt",
+                        basis: "activated_generation_proven",
                     },
                 };
                 try {
@@ -838,6 +868,13 @@ export class ManageIndexingHandlers {
             }
             else {
                 const operation = persistOperation("blocked");
+                if (result.reason === "repair_proof_limit") {
+                    return this.host.manageResponse("repair", absolutePath, "blocked", result.message, {
+                        reason: "repair_proof_limit",
+                        repairProof: result.proof,
+                        ...(operation ? { operation } : {}),
+                    });
+                }
                 const createHint = this.host.buildCreateHint(absolutePath);
                 return this.host.manageResponse("repair", absolutePath, "blocked", result.message, {
                     reason: result.reason || "needs_create",
@@ -853,7 +890,7 @@ export class ManageIndexingHandlers {
         }
         catch (error) {
             console.error("Error in handleRepairIndex:", error);
-            if (lastRepairProof?.navigation.basis === "call_graph_rebuild_in_progress") {
+            if (lastRepairProof?.navigation.basis === "generation_proof_in_progress") {
                 lastRepairProof = {
                     ...lastRepairProof,
                     navigation: {

package/dist/core/manage-types.d.ts

@@ -7,7 +7,7 @@ export type ManageIndexAction = (typeof MANAGE_INDEX_ACTIONS)[number];
 export type ManageIndexStatus = "ok" | "not_ready" | "not_indexed" | "requires_reindex" | "blocked" | "error";
 export declare const MANAGE_INDEX_STATUS_DETAILS: readonly ["summary", "capabilities", "diagnostics", "full"];
 export type ManageIndexStatusDetail = (typeof MANAGE_INDEX_STATUS_DETAILS)[number];
-export type ManageIndexReason = "indexing" | "not_indexed" | "requires_reindex" | "unnecessary_reindex_ignore_only" | "preflight_unknown" | "backend_timeout" | "remote_delete_pending" | "missing_provider_config" | "vector_backend_unavailable" | "runtime_owner_conflict" | "mutation_in_progress" | "needs_create";
+export type ManageIndexReason = "indexing" | "not_indexed" | "requires_reindex" | "unnecessary_reindex_ignore_only" | "preflight_unknown" | "backend_timeout" | "remote_delete_pending" | "missing_provider_config" | "vector_backend_unavailable" | "runtime_owner_conflict" | "mutation_in_progress" | "needs_create" | "repair_proof_limit";
 export type VectorBackendResponseCode = "ZILLIZ_CLUSTER_STOPPED" | "VECTOR_BACKEND_AUTH_FAILED" | "VECTOR_BACKEND_UNREACHABLE" | "VECTOR_BACKEND_TIMEOUT" | "VECTOR_BACKEND_CONNECTION_CLOSED";
 export type ManageReindexPreflightOutcome = "reindex_required" | "reindex_unnecessary_ignore_only" | "unknown" | "probe_failed";
 export interface ManageIndexToolHint {

package/dist/core/navigation-handlers.js

@@ -528,7 +528,6 @@ export class NavigationHandlers {
             const exactRegistrySymbols = findExactRegistrySymbols({
                 symbols: registryState.symbols,
                 symbolIdExact: symbolRef.symbolId,
-                symbolLabelExact: symbolRef.symbolLabel,
             });
             if (exactRegistrySymbols.length === 0) {
                 const payload = this.host.withProofDebugHint({

package/dist/core/python-call-fallback.js

@@ -140,21 +140,103 @@ function findPythonDefinitionIndexNearSpan(lines, symbol) {
     const windowEnd = Math.min(lines.length, Math.max(spanEndExclusive, startIndex + 48));
     return findPythonDefinitionIndexByName(lines, symbol.name, windowStart, windowEnd);
 }
+function isPythonDecoratorBlock(lines, startIndex, definitionIndex, indent) {
+    let delimiterDepth = 0;
+    let quote = null;
+    let tripleQuoted = false;
+    let escaped = false;
+    let expectsDecorator = true;
+    for (let index = startIndex; index < definitionIndex; index += 1) {
+        const line = lines[index] || "";
+        const trimmed = line.trim();
+        if (expectsDecorator) {
+            if (trimmed.length === 0
+                || !trimmed.startsWith("@")
+                || countPythonIndent(line) !== indent) {
+                return false;
+            }
+            expectsDecorator = false;
+        }
+        else if (trimmed.length === 0 && delimiterDepth === 0 && !tripleQuoted) {
+            return false;
+        }
+        for (let offset = 0; offset < line.length; offset += 1) {
+            const char = line[offset];
+            const nextTwo = line.slice(offset, offset + 3);
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (tripleQuoted && nextTwo === quote.repeat(3)) {
+                    quote = null;
+                    tripleQuoted = false;
+                    offset += 2;
+                    continue;
+                }
+                if (!tripleQuoted && char === quote) {
+                    quote = null;
+                }
+                continue;
+            }
+            if (char === "#") {
+                break;
+            }
+            if (nextTwo === "'''" || nextTwo === "\"\"\"") {
+                quote = char;
+                tripleQuoted = true;
+                offset += 2;
+                continue;
+            }
+            if (char === "'" || char === "\"") {
+                quote = char;
+                continue;
+            }
+            if (char === "(" || char === "[" || char === "{") {
+                delimiterDepth += 1;
+                continue;
+            }
+            if (char === ")" || char === "]" || char === "}") {
+                delimiterDepth -= 1;
+                if (delimiterDepth < 0) {
+                    return false;
+                }
+            }
+        }
+        const explicitContinuation = line.trimEnd().endsWith("\\");
+        if (!quote && delimiterDepth === 0 && !explicitContinuation) {
+            expectsDecorator = true;
+        }
+        else if (quote && !tripleQuoted) {
+            return false;
+        }
+        escaped = false;
+    }
+    return expectsDecorator && delimiterDepth === 0 && quote === null;
+}
 function findPythonDecoratedDefinitionStart(lines, definitionIndex) {
     const indent = countPythonIndent(lines[definitionIndex] || "");
-    let startIndex = definitionIndex;
+    const candidates = [];
     for (let index = definitionIndex - 1; index >= 0; index -= 1) {
         const line = lines[index] || "";
         const trimmed = line.trim();
-        if (trimmed.length === 0) {
+        if (trimmed.length === 0 && candidates.length === 0) {
             break;
         }
-        if (!trimmed.startsWith("@") || countPythonIndent(line) !== indent) {
-            break;
+        if (trimmed.startsWith("@") && countPythonIndent(line) === indent) {
+            candidates.push(index);
+        }
+    }
+    for (const candidate of candidates.reverse()) {
+        if (isPythonDecoratorBlock(lines, candidate, definitionIndex, indent)) {
+            return candidate;
         }
-        startIndex = index;
     }
-    return startIndex;
+    return definitionIndex;
 }
 function findPythonSourceBackedBlockEnd(lines, definitionIndex, indent) {
     let lastContentLine = definitionIndex + 1;

package/dist/core/relationship-backed-call-graph.d.ts

@@ -40,8 +40,6 @@ export type RelationshipBackedCallGraphResult = {
     };
     hints?: Record<string, unknown>;
 };
-/** True when a repo-relative path looks like a test/fixture site (not production call graph signal). */
-export declare function isTestOrFixtureCallerFile(file: string): boolean;
 /**
  * Prefer a single unique suppressed inbound caller *site* file for recovery search.
  * Prefer production files when both production and test sites exist.
@@ -58,6 +56,8 @@ export declare class RelationshipBackedCallGraph {
     private sortNodes;
     private compareEdges;
     private sortEdges;
+    private sortTestReferences;
+    private buildTestReferences;
     private sortNotes;
     private mapRelationshipConfidence;
     private createNode;