@danypops/lector 0.1.7 → 0.1.9

package/src/service.ts

@@ -1,15 +1,22 @@
 import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
 import { resolve } from "node:path";
+import { FallbackCodeIntelligenceIndex } from "./adapters/fallback-code-intelligence-index.ts";
 import { InMemorySearchCache } from "./adapters/in-memory-search-cache.ts";
 import { InMemorySymbolGraph } from "./adapters/in-memory-symbol-graph.ts";
 import { LocalFilesystemWorkspace } from "./adapters/local-filesystem-workspace.ts";
 import { LocalGit } from "./adapters/local-git.ts";
-import { discoverWorkspaceDescriptor } from "./adapters/lsp/discover-seed-file.ts";
+import { discoverWorkspaceDescriptor, discoverWorkspaceDescriptors } from "./adapters/lsp/discover-seed-file.ts";
 import { LspSymbolIndex } from "./adapters/lsp/lsp-symbol-index.ts";
+import { NpmLockfileVersionResolver } from "./adapters/npm-lockfile-version-resolver.ts";
+import { NpmPackageSourceResolver } from "./adapters/npm-package-source-resolver.ts";
+import { NpmRegistryClient } from "./adapters/npm-registry-client.ts";
+import { PolyglotCodeIntelligenceIndex } from "./adapters/polyglot-code-intelligence-index.ts";
 import { ReadOnlyWorkspace } from "./adapters/read-only-workspace.ts";
 import { RipgrepTextSearch } from "./adapters/ripgrep-text-search.ts";
 import { deriveSourceManifest } from "./adapters/source-manifest.ts";
+import { TreeSitterSymbolIndex } from "./adapters/tree-sitter/typescript-tree-sitter-symbol-index.ts";
+import { TypeScriptCompilerSymbolIndex } from "./adapters/typescript-compiler-symbol-index.ts";
 import { BoundedJobExecutor, type JobSnapshot } from "./domain/bounded-job-executor.ts";
 import type { CallHierarchyEntry, IncomingCall, OutgoingCall } from "./domain/call-hierarchy.ts";
 import type { Diagnostic } from "./domain/diagnostic.ts";
@@ -27,8 +34,10 @@ import { goToImplementation as goToImplementationQuery } from "./domain/go-to-im
 import type { Hover } from "./domain/hover.ts";
 import { hoverAt } from "./domain/hover-at.ts";
 import { incomingCalls as incomingCallsQuery } from "./domain/incoming-calls.ts";
+import type { IntelligenceProvenance } from "./domain/intelligence-provenance.ts";
 import { descriptorForPath, LANGUAGE_SERVER_DESCRIPTORS, type LanguageServerDescriptor } from "./domain/language-server-descriptor.ts";
 import { outgoingCalls as outgoingCallsQuery } from "./domain/outgoing-calls.ts";
+import type { PackageSourceBounds, PackageSourceOperationResult, PackageSourceRequest } from "./domain/package-source.ts";
 import { type PopulateSymbolGraphResult, populateSymbolGraph as populateSymbolGraphQuery } from "./domain/populate-symbol-graph.ts";
 import { prepareCallHierarchy as prepareCallHierarchyQuery } from "./domain/prepare-call-hierarchy.ts";
 import { raceWorkspaceQuery } from "./domain/race-workspace-query.ts";
@@ -36,16 +45,19 @@ import { type RawRead, rawRead, WorkspaceEntryNotFound } from "./domain/raw-read
 import { reachableSymbolsFrom } from "./domain/reachable-symbols-from.ts";
 import type { RepoFetchResult } from "./domain/repo-fetch-result.ts";
 import type { RepoReference } from "./domain/repo-reference.ts";
+import { resolvePackageSource } from "./domain/resolve-package-source.ts";
 import { searchText as searchTextQuery } from "./domain/search-text.ts";
 import { symbolEdgesFrom } from "./domain/symbol-edges-from.ts";
 import { symbolEdgesTo } from "./domain/symbol-edges-to.ts";
 import type { WorkspaceCacheStatus } from "./domain/symbol-graph-generation.ts";
 import { deriveSymbolNodeId } from "./domain/symbol-node-id.ts";
+import { assertBoundedSymbolQuery } from "./domain/symbol-query.ts";
 import type { TextSearchResult } from "./domain/text-search-result.ts";
 import type { WorkspaceQueryOutcome } from "./domain/workspace-query-outcome.ts";
-import type { WorkspaceLocation, WorkspaceSymbol } from "./domain/workspace-symbol.ts";
+import type { SymbolSearchResult, WorkspaceLocation } from "./domain/workspace-symbol.ts";
 import type { CodeIntelligencePort } from "./ports/code-intelligence-port.ts";
 import type { GitPort } from "./ports/git-port.ts";
+import type { PackageSourceResolverPort } from "./ports/package-source-resolver-port.ts";
 import type { RepoFetcherPort } from "./ports/repo-fetcher-port.ts";
 import type { SearchCachePort } from "./ports/search-cache-port.ts";
 import type { SymbolEdgeKind, SymbolGraphPort, SymbolNode } from "./ports/symbol-graph-port.ts";
@@ -128,6 +140,13 @@ export class RepoFetcherNotConfigured extends Error {
 	}
 }
 
+export class PackageSourceResolverNotConfigured extends Error {
+	constructor() {
+		super("package.resolveSource requires a service constructed with repository fetching");
+		this.name = "PackageSourceResolverNotConfigured";
+	}
+}
+
 export class UnsupportedJobOperation extends Error {
 	constructor(readonly operation: string) {
 		super(`operation "${operation}" cannot run as a background job; supported operations: workspace.populateSymbolGraph`);
@@ -185,6 +204,7 @@ export type OperationName =
 	| "workspace.gitLog"
 	| "workspace.gitDiff"
 	| "repo.fetch"
+	| "package.resolveSource"
 	| "workspace.searchText"
 	| "search.symbols"
 	| "search.text"
@@ -215,6 +235,7 @@ export const OPERATION_NAMES: readonly OperationName[] = [
 	"workspace.gitLog",
 	"workspace.gitDiff",
 	"repo.fetch",
+	"package.resolveSource",
 	"workspace.searchText",
 	"search.symbols",
 	"search.text",
@@ -234,7 +255,7 @@ export interface OperationInputs {
 	"workspace.rawRead": { workspaceId: WorkspaceId; path: string };
 	"workspace.exactEdit": { workspaceId: WorkspaceId } & ExpectedHashEdit;
 	"workspace.registerPath": { path: string };
-	"workspace.findSymbols": { workspaceId: WorkspaceId; query: string; seedFile?: string };
+	"workspace.findSymbols": { workspaceId: WorkspaceId; query: string; seedFile?: string; maxResults?: number };
 	"workspace.goToDefinition": WorkspacePosition;
 	"workspace.goToImplementation": WorkspacePosition;
 	"workspace.findReferences": WorkspacePosition & { includeDeclaration: boolean };
@@ -254,6 +275,7 @@ export interface OperationInputs {
 	"workspace.gitLog": { workspaceId: WorkspaceId; maxCount: number };
 	"workspace.gitDiff": { workspaceId: WorkspaceId; ref?: string; maxBytes: number };
 	"repo.fetch": RepoReference;
+	"package.resolveSource": { request: PackageSourceRequest; bounds: PackageSourceBounds };
 	"workspace.searchText": { workspaceId: WorkspaceId; query: string; maxMatches: number; maxBytes: number };
 	/**
 	 * No single workspaceId -- fans out across several at once, unlike every other findSymbols-
@@ -275,20 +297,22 @@ export interface OperationInputs {
 	"job.status": { jobId: string };
 }
 
+type Provenanced<T> = T & { readonly provenance: IntelligenceProvenance };
+
 export interface OperationOutputs {
 	"workspace.rawRead": RawRead;
 	"workspace.exactEdit": EditOutcome;
 	"workspace.registerPath": { workspaceId: WorkspaceId; created: boolean };
-	"workspace.findSymbols": { symbols: readonly WorkspaceSymbol[] };
-	"workspace.goToDefinition": { locations: readonly WorkspaceLocation[] };
-	"workspace.goToImplementation": { locations: readonly WorkspaceLocation[] };
-	"workspace.findReferences": { locations: readonly WorkspaceLocation[] };
-	"workspace.hover": { hover: Hover | undefined };
-	"workspace.documentSymbols": { symbols: readonly DocumentSymbolEntry[] };
-	"workspace.diagnostics": { diagnostics: readonly Diagnostic[] };
-	"workspace.prepareCallHierarchy": { items: readonly CallHierarchyEntry[] };
-	"workspace.incomingCalls": { calls: readonly IncomingCall[] };
-	"workspace.outgoingCalls": { calls: readonly OutgoingCall[] };
+	"workspace.findSymbols": SymbolSearchResult;
+	"workspace.goToDefinition": Provenanced<{ locations: readonly WorkspaceLocation[] }>;
+	"workspace.goToImplementation": Provenanced<{ locations: readonly WorkspaceLocation[] }>;
+	"workspace.findReferences": Provenanced<{ locations: readonly WorkspaceLocation[] }>;
+	"workspace.hover": Provenanced<{ hover: Hover | undefined }>;
+	"workspace.documentSymbols": Provenanced<{ symbols: readonly DocumentSymbolEntry[] }>;
+	"workspace.diagnostics": Provenanced<{ diagnostics: readonly Diagnostic[] }>;
+	"workspace.prepareCallHierarchy": Provenanced<{ items: readonly CallHierarchyEntry[] }>;
+	"workspace.incomingCalls": Provenanced<{ calls: readonly IncomingCall[] }>;
+	"workspace.outgoingCalls": Provenanced<{ calls: readonly OutgoingCall[] }>;
 	"workspace.populateSymbolGraph": { filesProcessed: number; symbolsProcessed: number; nodesAdded: number; edgesAdded: number };
 	"workspace.reachableFrom": { symbols: readonly SymbolNode[] };
 	"workspace.symbolEdgesFrom": { symbols: readonly SymbolNode[] };
@@ -299,8 +323,9 @@ export interface OperationOutputs {
 	"workspace.gitLog": { entries: readonly GitLogEntry[] };
 	"workspace.gitDiff": GitDiffResult;
 	"repo.fetch": RepoFetchResult & { workspaceId: WorkspaceId };
+	"package.resolveSource": PackageSourceOperationResult;
 	"workspace.searchText": TextSearchResult;
-	"search.symbols": { results: readonly WorkspaceQueryOutcome<{ symbols: readonly WorkspaceSymbol[] }>[] };
+	"search.symbols": { results: readonly WorkspaceQueryOutcome<SymbolSearchResult>[] };
 	"search.text": { results: readonly WorkspaceQueryOutcome<TextSearchResult>[] };
 	"job.submit": { job: JobSnapshot<PopulateSymbolGraphResult> };
 	"job.status": { job: JobSnapshot<PopulateSymbolGraphResult> };
@@ -366,6 +391,8 @@ export interface LectorServiceOptions {
 	createGitPort?: (rootPath: string) => GitPort;
 	/** Factory for the port backing repo.fetch. No default -- unlike createSymbolGraph's safe in-memory fallback, fetching a real external repo always needs a real disk location only a host (daemon.ts) can supply. Called once at construction and reused, not per-call. */
 	createRepoFetcher?: () => RepoFetcherPort;
+	/** Override package-source resolution. With a repo fetcher configured, the default composes npm lockfiles, registry metadata, and exact Git fetching. */
+	createPackageSourceResolver?: () => PackageSourceResolverPort;
 	/** Factory for the port backing workspace.searchText. Defaults to RipgrepTextSearch -- cheap to construct, no disk dependency, safe like createGitPort's default. Called once at construction and reused. */
 	createTextSearch?: () => TextSearchPort;
 	/** Factory for workspace.searchText's result cache. Defaults to an in-memory-only InMemorySearchCache -- safe, no disk dependency. A host wanting the disk-backed tier too (surviving a restart) supplies a TieredSearchCache here. Called once at construction and reused. */
@@ -382,7 +409,7 @@ function resolveWorkspace(registry: MutableRegistry, workspaceId: WorkspaceId):
 
 /** True when a warm SymbolIndexPort is also a real CodeIntelligencePort (currently: any LspSymbolIndex, never TreeSitterSymbolIndex). */
 function supportsCodeIntelligence(index: SymbolIndexPort): index is SymbolIndexPort & CodeIntelligencePort {
-	return typeof (index as Partial<CodeIntelligencePort>).goToDefinition === "function";
+	return "goToDefinition" in index && typeof index.goToDefinition === "function";
 }
 
 type OperationHandlers = {
@@ -418,6 +445,7 @@ async function registerPath(registry: MutableRegistry, input: OperationInputs["w
  */
 const DEFAULT_CROSS_WORKSPACE_TIMEOUT_MS = 3000;
 const MAX_INITIAL_JOB_WAIT_MS = 30_000;
+const MAX_SYMBOL_RESULTS = 5_000;
 const MAX_SOURCE_MANIFEST_BYTES = 50 * 1024 * 1024;
 
 /**
@@ -455,7 +483,11 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	const symbolIndexes = new Map<string, { index: ClosableSymbolIndex; workspaceId: WorkspaceId; lastUsedAt: number }>();
 	const createSymbolIndex =
 		options.createSymbolIndex ??
-		((rootPath: string, descriptor: LanguageServerDescriptor, seedFile?: string) => new LspSymbolIndex(rootPath, descriptor, seedFile));
+		((rootPath: string, descriptor: LanguageServerDescriptor, seedFile?: string) => {
+			const semantic = new LspSymbolIndex(rootPath, descriptor, seedFile);
+			if (descriptor.languageId !== "typescript") return semantic;
+			return new FallbackCodeIntelligenceIndex(semantic, [new TypeScriptCompilerSymbolIndex(rootPath), new TreeSitterSymbolIndex(rootPath)]);
+		});
 	function symbolIndexKey(workspaceId: WorkspaceId, languageId: string): string {
 		return `${workspaceId}:${languageId}`;
 	}
@@ -481,6 +513,11 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	// every time, wastefully, and would risk losing the in-memory LRU's recency ordering
 	// between calls for no benefit (the index itself is what makes rehydration correct at all).
 	const repoFetcher = options.createRepoFetcher?.();
+	const packageSourceResolver =
+		options.createPackageSourceResolver?.() ??
+		(repoFetcher
+			? new NpmPackageSourceResolver({ versions: new NpmLockfileVersionResolver(), registry: new NpmRegistryClient(), repositories: repoFetcher })
+			: undefined);
 	const textSearch = options.createTextSearch?.() ?? new RipgrepTextSearch();
 	const searchCache = options.createSearchCache?.() ?? new InMemorySearchCache();
 
@@ -521,6 +558,28 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 		return { workspaceId, ...result };
 	}
 
+	async function packageSourceHandler(
+		registry: MutableRegistry,
+		input: OperationInputs["package.resolveSource"],
+	): Promise<OperationOutputs["package.resolveSource"]> {
+		if (!packageSourceResolver) throw new PackageSourceResolverNotConfigured();
+		const outcome = await resolvePackageSource(packageSourceResolver, input.request, input.bounds);
+		if (outcome.status !== "verified") return { outcome, workspaceId: null };
+		const absolutePath = resolve(outcome.workspace.cachePath);
+		let sourceStats: Awaited<ReturnType<typeof stat>>;
+		try {
+			sourceStats = await stat(absolutePath);
+		} catch {
+			throw new InvalidWorkspaceRoot(absolutePath, "verified package source does not exist or is not accessible");
+		}
+		if (!sourceStats.isDirectory()) throw new InvalidWorkspaceRoot(absolutePath, "verified package source is not a directory");
+		const workspaceId = deriveWorkspaceId(absolutePath);
+		if (!registry.has(workspaceId)) {
+			registry.set(workspaceId, { port: new ReadOnlyWorkspace(new LocalFilesystemWorkspace(absolutePath)), rootPath: absolutePath, origin: "remote" });
+		}
+		return { outcome, workspaceId };
+	}
+
 	async function searchTextHandler(
 		registry: MutableRegistry,
 		input: OperationInputs["workspace.searchText"],
@@ -619,6 +678,18 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 		return { descriptor: discovered.descriptor, seedFile: discovered.seedFile };
 	}
 
+	function ensureLanguageIndex(workspaceId: WorkspaceId, rootPath: string, descriptor: LanguageServerDescriptor, seedFile?: string): ClosableSymbolIndex {
+		const key = symbolIndexKey(workspaceId, descriptor.languageId);
+		let entryIndex = symbolIndexes.get(key);
+		if (!entryIndex) {
+			entryIndex = { index: createSymbolIndex(rootPath, descriptor, seedFile), workspaceId, lastUsedAt: Date.now() };
+			symbolIndexes.set(key, entryIndex);
+		} else {
+			entryIndex.lastUsedAt = Date.now();
+		}
+		return entryIndex.index;
+	}
+
 	async function ensureWarmIndex(input: {
 		workspaceId: WorkspaceId;
 		path?: string;
@@ -627,18 +698,45 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 		const entry = registry.get(input.workspaceId);
 		if (!entry) throw new UnknownWorkspace(input.workspaceId);
 		if (!entry.rootPath) throw new SymbolQueryUnavailable(input.workspaceId);
-		const rootPath = entry.rootPath;
+		const { descriptor, seedFile } = resolveDescriptor(entry.rootPath, input);
+		return { index: ensureLanguageIndex(input.workspaceId, entry.rootPath, descriptor, seedFile), descriptor };
+	}
 
-		const { descriptor, seedFile } = resolveDescriptor(rootPath, input);
-		const key = symbolIndexKey(input.workspaceId, descriptor.languageId);
-		let entryIndex = symbolIndexes.get(key);
-		if (!entryIndex) {
-			entryIndex = { index: createSymbolIndex(rootPath, descriptor, seedFile), workspaceId: input.workspaceId, lastUsedAt: Date.now() };
-			symbolIndexes.set(key, entryIndex);
+	function ensureWorkspaceIndex(
+		workspaceId: WorkspaceId,
+		preferredSeedFile?: string,
+	): {
+		index: SymbolIndexPort;
+		descriptors: readonly LanguageServerDescriptor[];
+		sources: readonly IntelligenceProvenance[];
+	} {
+		const entry = registry.get(workspaceId);
+		if (!entry) throw new UnknownWorkspace(workspaceId);
+		if (!entry.rootPath) throw new SymbolQueryUnavailable(workspaceId);
+		const rootPath = entry.rootPath;
+		const preferredDescriptor = preferredSeedFile ? descriptorForPath(preferredSeedFile) : undefined;
+		if (preferredSeedFile && !preferredDescriptor) throw new UnsupportedLanguage(preferredSeedFile);
+		const discovered = [...discoverWorkspaceDescriptors(rootPath, LANGUAGE_SERVER_DESCRIPTORS)];
+		if (preferredDescriptor && preferredSeedFile && !discovered.some(({ descriptor }) => descriptor.languageId === preferredDescriptor.languageId)) {
+			discovered.push({ descriptor: preferredDescriptor, seedFile: preferredSeedFile });
+		}
+		if (discovered.length === 0) throw new UnsupportedLanguage(rootPath);
+		const indexes = discovered.map(({ descriptor, seedFile }) => ({
+			descriptor,
+			index: ensureLanguageIndex(workspaceId, rootPath, descriptor, preferredDescriptor?.languageId === descriptor.languageId ? preferredSeedFile : seedFile),
+		}));
+		const first = indexes[0];
+		let index: SymbolIndexPort;
+		if (indexes.length === 1 && first) {
+			index = first.index;
 		} else {
-			entryIndex.lastUsedAt = Date.now();
+			index = new PolyglotCodeIntelligenceIndex(indexes);
 		}
-		return { index: entryIndex.index, descriptor };
+		return { index, descriptors: discovered.map(({ descriptor }) => descriptor), sources: indexes.map(({ index: source }) => source.provenance) };
+	}
+
+	function workspaceSourceExtensions(descriptors: readonly LanguageServerDescriptor[]): readonly string[] {
+		return Array.from(new Set(descriptors.flatMap((descriptor) => descriptor.extensions)));
 	}
 
 	/** Never spawns -- a caller deciding whether to enrich a result with LSP-backed info must not pay a cold-start cost just to check. With a path, checks that file's own language; without one, whether anything is warm for the workspace at all. */
@@ -660,9 +758,13 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	}
 
 	async function findSymbols(_registry: MutableRegistry, input: OperationInputs["workspace.findSymbols"]): Promise<OperationOutputs["workspace.findSymbols"]> {
-		const { index } = await ensureWarmIndex(input);
-		const symbols = await findWorkspaceSymbols(index, input.query);
-		return { symbols };
+		assertBoundedSymbolQuery(input.query);
+		const maxResults = input.maxResults ?? 1_000;
+		if (!Number.isSafeInteger(maxResults) || maxResults < 1 || maxResults > MAX_SYMBOL_RESULTS) {
+			throw new TypeError(`maxResults must be a positive safe integer no greater than ${MAX_SYMBOL_RESULTS}`);
+		}
+		const { index } = ensureWorkspaceIndex(input.workspaceId, input.seedFile);
+		return findWorkspaceSymbols(index, input.query, { maxResults });
 	}
 
 	async function requireCodeIntelligence(input: {
@@ -681,7 +783,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.goToDefinition"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const locations = await goToDefinitionQuery(index, { path: input.path, line: input.line, character: input.character });
-		return { locations };
+		return { locations, provenance: index.provenance };
 	}
 
 	async function goToImplementation(
@@ -690,7 +792,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.goToImplementation"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const locations = await goToImplementationQuery(index, { path: input.path, line: input.line, character: input.character });
-		return { locations };
+		return { locations, provenance: index.provenance };
 	}
 
 	async function findReferences(
@@ -699,13 +801,13 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.findReferences"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const locations = await findReferencesQuery(index, { path: input.path, line: input.line, character: input.character }, input.includeDeclaration);
-		return { locations };
+		return { locations, provenance: index.provenance };
 	}
 
 	async function hover(_registry: MutableRegistry, input: OperationInputs["workspace.hover"]): Promise<OperationOutputs["workspace.hover"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const hover = await hoverAt(index, { path: input.path, line: input.line, character: input.character });
-		return { hover };
+		return { hover, provenance: index.provenance };
 	}
 
 	async function documentSymbolsHandler(
@@ -714,7 +816,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.documentSymbols"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const symbols = await documentSymbolsQuery(index, input.path);
-		return { symbols };
+		return { symbols, provenance: index.provenance };
 	}
 
 	async function diagnosticsHandler(
@@ -723,7 +825,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.diagnostics"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const diagnostics = await diagnosticsQuery(index, input.path);
-		return { diagnostics };
+		return { diagnostics, provenance: index.provenance };
 	}
 
 	async function prepareCallHierarchyHandler(
@@ -732,7 +834,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.prepareCallHierarchy"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const items = await prepareCallHierarchyQuery(index, { path: input.path, line: input.line, character: input.character });
-		return { items };
+		return { items, provenance: index.provenance };
 	}
 
 	async function incomingCallsHandler(
@@ -741,7 +843,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.incomingCalls"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const calls = await incomingCallsQuery(index, { path: input.path, line: input.line, character: input.character });
-		return { calls };
+		return { calls, provenance: index.provenance };
 	}
 
 	async function outgoingCallsHandler(
@@ -750,27 +852,31 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 	): Promise<OperationOutputs["workspace.outgoingCalls"]> {
 		const { index } = await requireCodeIntelligence(input);
 		const calls = await outgoingCallsQuery(index, { path: input.path, line: input.line, character: input.character });
-		return { calls };
+		return { calls, provenance: index.provenance };
 	}
 
 	async function populateSymbolGraphHandler(
 		_registry: MutableRegistry,
 		input: OperationInputs["workspace.populateSymbolGraph"],
 	): Promise<OperationOutputs["workspace.populateSymbolGraph"]> {
-		const { index, descriptor } = await requireCodeIntelligence(input);
+		const workspaceIndex = ensureWorkspaceIndex(input.workspaceId);
+		if (!supportsCodeIntelligence(workspaceIndex.index)) throw new CodeIntelligenceUnavailable(input.workspaceId);
 		const entry = registry.get(input.workspaceId);
 		if (!entry?.rootPath) throw new SymbolQueryUnavailable(input.workspaceId);
 		const rootPath = entry.rootPath;
-		const before = await deriveSourceManifest(rootPath, descriptor.extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES);
+		const extensions = workspaceSourceExtensions(workspaceIndex.descriptors);
+		const before = await deriveSourceManifest(rootPath, extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES);
 		const graph = ensureSymbolGraph(input.workspaceId);
-		const result = await populateSymbolGraphQuery(index, graph, before.absoluteFiles, input.maxSymbolsPerFile);
-		const after = await deriveSourceManifest(rootPath, descriptor.extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES);
+		const result = await populateSymbolGraphQuery(workspaceIndex.index, graph, before.absoluteFiles, input.maxSymbolsPerFile);
+		const after = await deriveSourceManifest(rootPath, extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES);
 		if (after.fingerprint !== before.fingerprint) throw new WorkspaceChangedDuringPopulation(input.workspaceId);
 		await graph.setGeneration({
 			sourceFingerprint: after.fingerprint,
 			maxFiles: input.maxFiles,
 			maxSymbolsPerFile: input.maxSymbolsPerFile,
 			completedAt: Date.now(),
+			provenance: workspaceIndex.index.provenance,
+			sources: workspaceIndex.sources,
 			result,
 		});
 		return result;
@@ -795,10 +901,12 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 		if (generation.maxFiles !== input.maxFiles || generation.maxSymbolsPerFile !== input.maxSymbolsPerFile) {
 			return { status: "not-cached", reason: "bounds-changed" };
 		}
-		const { descriptor } = resolveDescriptor(entry.rootPath, {});
+		const discovered = discoverWorkspaceDescriptors(entry.rootPath, LANGUAGE_SERVER_DESCRIPTORS);
+		if (discovered.length === 0) return { status: "not-cached", reason: "source-changed" };
+		const extensions = workspaceSourceExtensions(discovered.map(({ descriptor }) => descriptor));
 		let currentFingerprint: string;
 		try {
-			currentFingerprint = (await deriveSourceManifest(entry.rootPath, descriptor.extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES)).fingerprint;
+			currentFingerprint = (await deriveSourceManifest(entry.rootPath, extensions, input.maxFiles, MAX_SOURCE_MANIFEST_BYTES)).fingerprint;
 		} catch {
 			return { status: "not-cached", reason: "source-changed" };
 		}
@@ -920,6 +1028,7 @@ export function createLectorService(workspaces: ReadonlyMap<WorkspaceId, Workspa
 		"workspace.gitLog": gitLogHandler,
 		"workspace.gitDiff": gitDiffHandler,
 		"repo.fetch": repoFetchHandler,
+		"package.resolveSource": packageSourceHandler,
 		"workspace.searchText": searchTextHandler,
 		"search.symbols": crossFindSymbols,
 		"search.text": crossSearchText,