@danypops/pi-lector 0.9.5 → 0.10.0

package/extension/src/editor/neovim-editor-component.ts

@@ -0,0 +1,199 @@
+import { extname } from "node:path";
+import type { HighlightSpan } from "@danypops/lector";
+import { highlightSpans } from "@danypops/lector";
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { EditorAction } from "./editor-state.ts";
+import { EditorState } from "./editor-state.ts";
+
+/** Real theme, narrowed to exactly what this component needs -- avoids depending on pi-coding-agent's full internal Theme shape. */
+export interface EditorTheme {
+	fg(color: ThemeColor, text: string): string;
+	bg(color: "selectedBg", text: string): string;
+}
+
+export interface NeovimEditorHost {
+	filePath: string;
+	/** Saves the buffer's current text through Lector's hash-guarded write. Throws (surfaced as a status message, not a crash) on a genuinely concurrent external change. */
+	save(text: string): Promise<void>;
+	/** Real hover info from Lector's existing code-intelligence operation, or undefined when there is none at this position. */
+	hover(line: number, character: number): Promise<{ contents: string } | undefined>;
+}
+
+const CAPTURE_COLOR: Record<string, ThemeColor> = {
+	keyword: "syntaxKeyword",
+	comment: "syntaxComment",
+	string: "syntaxString",
+	number: "syntaxNumber",
+	function: "syntaxFunction",
+	type: "syntaxType",
+};
+
+/**
+ * A real, full-file, neovim-style modal code editor Component -- not a CustomEditor subclass
+ * (that API replaces Pi's own chat input, not a full-file view; confirmed against
+ * docs/tui.md's Pattern 7 and examples/extensions/modal-editor.ts). Renders as a `ctx.ui.custom`
+ * overlay. Owns no authoritative state of its own past the open edit session: `EditorState`'s
+ * LiveBuffer is the only in-memory copy, and every save round-trips through the host's
+ * hash-guarded write -- never a second source of truth for the file's real disk content.
+ */
+export class NeovimEditorComponent implements Component {
+	private readonly state: EditorState;
+	private readonly host: NeovimEditorHost;
+	private readonly tui: TUI;
+	private readonly theme: EditorTheme;
+	private readonly done: () => void;
+	private readonly extension: string;
+
+	private scrollTop = 1;
+	private statusMessage = "";
+	private highlightCache: { text: string; spans: readonly HighlightSpan[] } | undefined;
+
+	constructor(tui: TUI, theme: EditorTheme, host: NeovimEditorHost, content: string, done: () => void) {
+		this.tui = tui;
+		this.theme = theme;
+		this.host = host;
+		this.done = done;
+		this.extension = extname(host.filePath);
+		this.state = new EditorState(content);
+		void this.refreshHighlights();
+	}
+
+	invalidate(): void {
+		this.highlightCache = undefined;
+	}
+
+	handleInput(data: string): void {
+		this.state.handleKey(data);
+		this.scrollToKeepCursorVisible();
+		const action = this.state.pendingAction;
+		if (action) void this.performAction(action);
+		this.tui.requestRender();
+	}
+
+	private async performAction(action: EditorAction): Promise<void> {
+		switch (action.kind) {
+			case "save":
+			case "save-and-quit": {
+				try {
+					await this.host.save(this.state.buffer.text);
+					this.state.dirty = false;
+					this.statusMessage = `"${this.host.filePath}" written`;
+				} catch (error) {
+					this.statusMessage = `save failed: ${error instanceof Error ? error.message : String(error)}`;
+					this.tui.requestRender();
+					return;
+				}
+				if (action.kind === "save-and-quit") {
+					this.done();
+					return;
+				}
+				break;
+			}
+			case "quit":
+				this.done();
+				return;
+			case "hover": {
+				const hover = await this.host.hover(this.state.cursorLine, this.state.cursorCharacter);
+				const firstLine = hover?.contents.split("\n")[0];
+				this.statusMessage = firstLine ?? "no hover info at this position";
+				break;
+			}
+			default: {
+				const exhaustive: never = action;
+				throw new Error(`Unhandled editor action: ${JSON.stringify(exhaustive)}`);
+			}
+		}
+		this.tui.requestRender();
+	}
+
+	private async refreshHighlights(): Promise<void> {
+		const text = this.state.buffer.text;
+		const spans = await highlightSpans(text, this.extension);
+		this.highlightCache = { text, spans };
+		this.tui.requestRender();
+	}
+
+	private scrollToKeepCursorVisible(): void {
+		const viewportHeight = Math.max(1, this.tui.terminal.rows - 2);
+		if (this.state.cursorLine < this.scrollTop) this.scrollTop = this.state.cursorLine;
+		else if (this.state.cursorLine >= this.scrollTop + viewportHeight) this.scrollTop = this.state.cursorLine - viewportHeight + 1;
+	}
+
+	render(width: number): string[] {
+		if (this.highlightCache?.text !== this.state.buffer.text) void this.refreshHighlights();
+
+		const viewportHeight = Math.max(1, this.tui.terminal.rows - 2);
+		const gutterWidth = Math.max(3, String(this.state.buffer.lineCount).length) + 1;
+		const lastLine = Math.min(this.state.buffer.lineCount, this.scrollTop + viewportHeight - 1);
+
+		const lines: string[] = [];
+		for (let line = this.scrollTop; line <= lastLine; line++) {
+			lines.push(this.renderLine(line, gutterWidth, width - gutterWidth));
+		}
+		while (lines.length < viewportHeight) lines.push("");
+
+		lines.push(this.renderStatusLine(width));
+		return lines;
+	}
+
+	private renderLine(line: number, gutterWidth: number, contentWidth: number): string {
+		const isCursorLine = line === this.state.cursorLine;
+		const gutterNumber = isCursorLine ? String(line) : String(Math.abs(line - this.state.cursorLine));
+		const gutter = `${this.theme.fg(isCursorLine ? "text" : "muted", gutterNumber.padStart(gutterWidth - 1))} `;
+
+		const lineText = this.state.buffer.lineText(line);
+		const rendered = isCursorLine ? this.renderLineWithCursor(line, lineText) : this.renderHighlightedLine(line, lineText);
+		return gutter + truncateToWidth(rendered, contentWidth, "");
+	}
+
+	private spansForLine(line: number): readonly HighlightSpan[] {
+		if (!this.highlightCache) return [];
+		const from = this.state.buffer.offsetAt({ line, character: 1 });
+		const to = from + this.state.buffer.lineText(line).length;
+		return this.highlightCache.spans.filter((span) => span.startIndex < to && span.endIndex > from);
+	}
+
+	private renderHighlightedLine(line: number, lineText: string): string {
+		const from = this.state.buffer.offsetAt({ line, character: 1 });
+		const spans = this.spansForLine(line);
+		let result = "";
+		let cursor = 0;
+		for (const span of spans) {
+			const start = Math.max(span.startIndex - from, 0);
+			const end = Math.min(span.endIndex - from, lineText.length);
+			if (start < cursor) continue; // overlapping captures -- keep the earliest, simplest for v1
+			result += lineText.slice(cursor, start);
+			const color = CAPTURE_COLOR[span.capture];
+			result += color ? this.theme.fg(color, lineText.slice(start, end)) : lineText.slice(start, end);
+			cursor = end;
+		}
+		result += lineText.slice(cursor);
+		return result;
+	}
+
+	/** The cursor's own line: highlighted text plus an inverse-video cursor cell, matching pi-tui's own Editor cursor convention. */
+	private renderLineWithCursor(line: number, lineText: string): string {
+		const highlighted = this.renderHighlightedLine(line, lineText);
+		// Re-slicing a pre-highlighted (ANSI-embedded) string by character index would misplace the
+		// cursor inside escape codes -- render the cursor against the plain text, forgoing this
+		// line's syntax highlighting. Acceptable for v1: only one line is ever affected at a time.
+		void highlighted;
+		const col = this.state.cursorCharacter - 1;
+		const before = lineText.slice(0, col);
+		const atCursor = col < lineText.length ? lineText[col] : " ";
+		const after = col < lineText.length ? lineText.slice(col + 1) : "";
+		return `${before}\x1b[7m${atCursor}\x1b[0m${after}`;
+	}
+
+	private renderStatusLine(width: number): string {
+		const modeLabel = { normal: " NORMAL ", insert: " INSERT ", command: " COMMAND " }[this.state.mode];
+		const dirtyMarker = this.state.dirty ? " [+]" : "";
+		const position = `${this.state.cursorLine}:${this.state.cursorCharacter}`;
+		const left = this.state.mode === "command" ? `:${this.state.commandText}` : `${this.theme.fg("accent", modeLabel)} ${this.host.filePath}${dirtyMarker}`;
+		const right = this.statusMessage || position;
+		const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+		return truncateToWidth(`${left}${" ".repeat(gap)}${right}`, width, "");
+	}
+}

package/extension/src/editor/operations.ts

@@ -0,0 +1,36 @@
+import type { ContentHash } from "@danypops/lector";
+import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { toWorkspaceRelativePath } from "../workspace-relative-path.ts";
+
+export interface EditorFileSession {
+	readonly content: string;
+	/**
+	 * Saves through Lector's hash-guarded `workspace.exactEdit` -- deliberately NOT the
+	 * transparent stale-hash-retry behavior `createLectorWriteOperations` uses for pi's
+	 * unconditional-overwrite write tool. `/editor`'s `:w` is a human editing a file they can see
+	 * on screen; a genuinely concurrent external change must surface as a real, visible error
+	 * (StaleExpectedHash), never be silently overwritten just because the model's write-tool
+	 * contract happens to prefer that elsewhere.
+	 */
+	save(text: string): Promise<void>;
+}
+
+/** Opens `absolutePath` for `/editor`: one hash-guarded read, then a save() closure that tracks the hash across saves within the same session. */
+export function openEditorFile(absolutePath: string): Promise<EditorFileSession> {
+	return withWorkspace(
+		() => workspaceForPath(absolutePath),
+		async ({ workspaceId, root }) => {
+			const client = await lectorClient();
+			const relativePath = toWorkspaceRelativePath(root, absolutePath);
+			const { content, hash } = await client.call("workspace.rawRead", { workspaceId, path: relativePath });
+			let expectedHash: ContentHash | null = hash;
+			return {
+				content,
+				async save(text: string): Promise<void> {
+					const outcome = await client.callOnce("workspace.exactEdit", { workspaceId, path: relativePath, expectedHash, content: text });
+					expectedHash = outcome.newHash;
+				},
+			};
+		},
+	);
+}

package/extension/src/{external-search-operations.ts → external-search/operations.ts}

@@ -1,5 +1,5 @@
 import type { GithubRepoSearchResult, NpmPackageCandidate, SourcegraphCodeCandidate } from "@danypops/lector";
-import { lectorClient } from "./lector-client.ts";
+import { lectorClient } from "../lector-client.ts";
 
 /** Thin wrapper over search.githubRepos/search.npmPackages/search.sourcegraphCode -- explicit-query discovery inputs shaped for repo_cache/package_source, never open-ended discovery/trending. */
 export interface ExternalSearchOperations {

package/extension/src/{external-search-rendering.ts → external-search/rendering.ts}

@@ -1,5 +1,5 @@
 import type { GithubRepoSearchResult, NpmPackageCandidate, SourcegraphCodeCandidate } from "@danypops/lector";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 type ExternalSearchAction = "github_repos" | "npm_packages" | "sourcegraph_code";
 

package/extension/src/{find-files-operations.ts → find-files/operations.ts}

@@ -1,5 +1,5 @@
 import type { FindFilesResult } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
 
 /**
  * Thin wrapper over workspace.findFiles -- the `find`-shaped half of the classic grep+find pair,

package/extension/src/{find-files-rendering.ts → find-files/rendering.ts}

@@ -1,7 +1,7 @@
 import type { FindFilesResult } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList } from "malevich-tui-components";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 const DEFAULT_VISIBLE_PATHS = 40;
 

package/extension/src/{find-symbols-operations.ts → find-symbols/operations.ts}

@@ -1,5 +1,5 @@
 import type { OperationInputs, SymbolSearchResult } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
 
 /**
  * Thin wrapper over workspace.findSymbols. No seedFile parameter here or

package/extension/src/{find-symbols-rendering.ts → find-symbols/rendering.ts}

@@ -1,7 +1,7 @@
 import type { SymbolSearchResult, WorkspaceSymbol } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList } from "malevich-tui-components";
-import { colorForKind, formatLocation, type LectorTheme } from "./lector-tui-theme.ts";
+import { colorForKind, formatLocation, type LectorTheme } from "../lector-tui-theme.ts";
 
 /**
  * Custom TUI rendering for find_symbols -- the one Lector-backed tool with

package/extension/src/{git-operations.ts → git/operations.ts}

@@ -1,5 +1,5 @@
 import type { GitDiffResult, GitLogEntry, GitStatusSummary, OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
 
 type SymbolComparison = OperationOutputs["workspace.compareSymbolAcrossVersions"];
 

package/extension/src/{git-rendering.ts → git/rendering.ts}

@@ -2,7 +2,7 @@ import type { GitDiffResult, GitLogEntry, GitStatusSummary, OperationOutputs } f
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { renderDiffLines, renderTruncatedList, type TextMeasure } from "malevich-tui-components";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 /** Real ANSI-aware measurement, not Malevich's own ASCII-only default -- every diff line renderDiffLines receives is already theme.fg-styled. */
 const measure: TextMeasure = { visibleWidth, truncateToWidth };

package/extension/src/index.ts

@@ -27,7 +27,6 @@ import type {
 	WorkspaceCacheStatus,
 	WorkspaceLocation,
 	WorkspaceMapResult,
-	WorkspaceQueryOutcome,
 } from "@danypops/lector";
 import { DEFAULT_EXTERNAL_SEARCH_MAX_RESULTS, PACKAGE_ECOSYSTEMS } from "@danypops/lector";
 import {
@@ -44,9 +43,9 @@ import { Type } from "typebox";
 /** Real ANSI-aware measurement for Table -- Malevich's own default is ASCII-only, unsafe against theme-styled cell/header text. */
 const tableMeasure: TextMeasure = { visibleWidth, truncateToWidth };
 
-import { createLectorApplyPatchOperations } from "./apply-patch-operations.ts";
-import { formatApplyPatchCall, formatApplyPatchResult } from "./apply-patch-rendering.ts";
-import { createLectorCodeIntelligenceOperations } from "./code-intelligence-operations.ts";
+import { createLectorApplyPatchOperations } from "./apply-patch/operations.ts";
+import { formatApplyPatchCall, formatApplyPatchResult } from "./apply-patch/rendering.ts";
+import { createLectorCodeIntelligenceOperations } from "./code-intelligence/operations.ts";
 import {
 	type CallHierarchyToolDetails,
 	formatCallHierarchyCall,
@@ -67,29 +66,31 @@ import {
 	formatReachableFromResult,
 	formatWorkspaceMapCall,
 	formatWorkspaceMapResult,
-} from "./code-intelligence-rendering.ts";
-import { createLectorCrossWorkspaceSearchOperations } from "./cross-workspace-search-operations.ts";
-import { formatCrossWorkspaceCall, formatFindSymbolsAcrossProjectsResult, formatSearchTextAcrossProjectsResult } from "./cross-workspace-search-rendering.ts";
-import { createLectorEditOperations } from "./edit-operations.ts";
-import { createExternalSearchOperations } from "./external-search-operations.ts";
+} from "./code-intelligence/rendering.ts";
+import { type CrossWorkspaceOutcome, createLectorCrossWorkspaceSearchOperations } from "./cross-workspace-search/operations.ts";
+import { formatCrossWorkspaceCall, formatFindSymbolsAcrossProjectsResult, formatSearchTextAcrossProjectsResult } from "./cross-workspace-search/rendering.ts";
+import { createLectorEditOperations } from "./edit/operations.ts";
+import { NeovimEditorComponent, type NeovimEditorHost } from "./editor/neovim-editor-component.ts";
+import { openEditorFile } from "./editor/operations.ts";
+import { createExternalSearchOperations } from "./external-search/operations.ts";
 import {
 	formatExternalSearchCall,
 	formatGithubRepoSearchResult,
 	formatNpmPackageSearchResult,
 	formatSourcegraphCodeSearchResult,
-} from "./external-search-rendering.ts";
-import { createLectorFindFilesOperations } from "./find-files-operations.ts";
-import { formatFindFilesCall, formatFindFilesResult } from "./find-files-rendering.ts";
-import { createLectorFindSymbolsOperations } from "./find-symbols-operations.ts";
-import { describeFindSymbolSources, formatFindSymbolsCall, formatFindSymbolsResult } from "./find-symbols-rendering.ts";
-import { createLectorGitOperations } from "./git-operations.ts";
-import { formatGitCall, formatGitResult, type GitToolDetails } from "./git-rendering.ts";
+} from "./external-search/rendering.ts";
+import { createLectorFindFilesOperations } from "./find-files/operations.ts";
+import { formatFindFilesCall, formatFindFilesResult } from "./find-files/rendering.ts";
+import { createLectorFindSymbolsOperations } from "./find-symbols/operations.ts";
+import { describeFindSymbolSources, formatFindSymbolsCall, formatFindSymbolsResult } from "./find-symbols/rendering.ts";
+import { createLectorGitOperations } from "./git/operations.ts";
+import { formatGitCall, formatGitResult, type GitToolDetails } from "./git/rendering.ts";
 import { setNewWorkspaceObserver } from "./lector-client.ts";
-import { createLectorLineEditOperations } from "./line-edit-operations.ts";
-import { formatLineEditCall, formatLineEditResult } from "./line-edit-rendering.ts";
-import { createMutationHistoryOperations } from "./mutation-history-operations.ts";
+import { createLectorLineEditOperations } from "./line-edit/operations.ts";
+import { formatLineEditCall, formatLineEditResult } from "./line-edit/rendering.ts";
+import { createMutationHistoryOperations } from "./mutation-history/operations.ts";
 import { isFilesystemRoot, nearestGitRoot } from "./nearest-workspace-root.ts";
-import { createLectorPackageSourceOperations, type PackageSourceListPage } from "./package-source-operations.ts";
+import { createLectorPackageSourceOperations, type PackageSourceListPage } from "./package-source/operations.ts";
 import {
 	buildPackageSourceListTableRows,
 	formatPackageSourceCall,
@@ -100,12 +101,12 @@ import {
 	PACKAGE_SOURCE_LIST_TABLE_COLUMNS,
 	PACKAGE_SOURCE_LIST_VISIBLE_ROWS,
 	packageSourceListMoreLine,
-} from "./package-source-rendering.ts";
-import { createLectorReadOperations } from "./read-operations.ts";
-import { createReferenceBasedRenameOperations } from "./reference-based-rename-operations.ts";
-import { createRenameOperations } from "./rename-operations.ts";
-import { createRepoCacheEvictOperations } from "./repo-cache-evict-operations.ts";
-import { createRepoCacheListOperations } from "./repo-cache-list-operations.ts";
+} from "./package-source/rendering.ts";
+import { createLectorReadOperations } from "./read/operations.ts";
+import { createReferenceBasedRenameOperations } from "./reference-based-rename/operations.ts";
+import { createRenameOperations } from "./rename/operations.ts";
+import { createRepoCacheEvictOperations } from "./repo-cache/evict-operations.ts";
+import { createRepoCacheListOperations } from "./repo-cache/list-operations.ts";
 import {
 	buildRepoCacheTableRows,
 	formatRepoCacheCall,
@@ -115,21 +116,21 @@ import {
 	REPO_CACHE_TABLE_COLUMNS,
 	REPO_CACHE_VISIBLE_ROWS,
 	repoCacheMoreLine,
-} from "./repo-cache-rendering.ts";
-import { createLectorRepoFetchOperations } from "./repo-fetch-operations.ts";
-import { createLectorSearchOperations } from "./search-operations.ts";
-import { formatSearchCall, formatSearchResult } from "./search-rendering.ts";
-import { type AnnotationAnchorInput, createLectorSymbolAnnotationOperations } from "./symbol-annotation-operations.ts";
-import { formatAnnotationDetail, formatAnnotationListSummary, formatAnnotationSummary } from "./symbol-annotation-rendering.ts";
+} from "./repo-cache/rendering.ts";
+import { createLectorRepoFetchOperations } from "./repo-fetch/operations.ts";
+import { createLectorSearchOperations } from "./search/operations.ts";
+import { formatSearchCall, formatSearchResult } from "./search/rendering.ts";
+import { type AnnotationAnchorInput, createLectorSymbolAnnotationOperations } from "./symbol-annotation/operations.ts";
+import { formatAnnotationDetail, formatAnnotationListSummary, formatAnnotationSummary } from "./symbol-annotation/rendering.ts";
 import {
 	type CachePresentationState,
 	cacheContextMessage,
 	createWorkspaceCacheOperations,
 	describeCacheState,
 	monitorWorkspaceCache,
-} from "./workspace-cache-operations.ts";
-import { formatJobSnapshotResult, formatWorkspaceCacheCall, formatWorkspaceCacheStatusResult } from "./workspace-cache-rendering.ts";
-import { createLectorWriteOperations } from "./write-operations.ts";
+} from "./workspace-cache/operations.ts";
+import { formatJobSnapshotResult, formatWorkspaceCacheCall, formatWorkspaceCacheStatusResult } from "./workspace-cache/rendering.ts";
+import { createLectorWriteOperations } from "./write/operations.ts";
 
 function describeIntelligenceSource(provenance: IntelligenceProvenance): string {
 	return `${provenance.fidelity} via ${provenance.backend}`;
@@ -345,6 +346,42 @@ export default function (pi: ExtensionAPI) {
 		});
 
 		const codeIntelligenceOperations = createLectorCodeIntelligenceOperations();
+
+		pi.registerCommand("editor", {
+			description: "Open a file in a neovim-style modal code editor",
+			handler: async (args, commandCtx) => {
+				const target = args.trim();
+				if (!target) {
+					commandCtx.ui.notify("Usage: /editor <path>", "error");
+					return;
+				}
+				const absolutePath = resolve(commandCtx.cwd, target);
+
+				let session: Awaited<ReturnType<typeof openEditorFile>>;
+				try {
+					session = await openEditorFile(absolutePath);
+				} catch (error) {
+					commandCtx.ui.notify(`Could not open ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+					return;
+				}
+
+				await commandCtx.ui.custom<void>(
+					(tui, theme, _keybindings, done) => {
+						const host: NeovimEditorHost = {
+							filePath: absolutePath,
+							save: (text) => session.save(text),
+							hover: async (line, character) => {
+								const result = await codeIntelligenceOperations.hover(absolutePath, line, character);
+								return result.hover;
+							},
+						};
+						return new NeovimEditorComponent(tui, theme, host, session.content, () => done(undefined));
+					},
+					{ overlay: true, overlayOptions: { width: "100%", maxHeight: "100%", anchor: "center" } },
+				);
+			},
+		});
+
 		const referenceBasedRenameOperations = createReferenceBasedRenameOperations();
 		const renameOperations = createRenameOperations();
 		const positionParameters = {
@@ -1725,7 +1762,7 @@ export default function (pi: ExtensionAPI) {
 			name: "find_symbols_across_projects",
 			label: "Find Symbols Across Projects",
 			description:
-				"Fans out a symbol-name search across several explicitly-named project directories at once (e.g. several fetched repos, or a handful of related local projects) and reports one outcome per project -- ready with real results, loading (a project's language server is still cold-starting; retry shortly), or error. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions.",
+				"Fans out a symbol-name search across several explicitly-named project directories at once (e.g. several fetched repos, or a handful of related local projects) and reports one outcome per project -- ready with real results, loading (a project's language server is still cold-starting; retry shortly), or error. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions. Each directory resolves to its OWN nearest project root (package.json/tsconfig.json/go.mod/Cargo.toml/...), not the outer repo's git root -- sibling packages under one monorepo stay distinct scopes rather than collapsing into one. A result's collapsedWith lists any other requested directories that genuinely did resolve to the same workspace; empty means it got its own.",
 			promptSnippet: "Search for a symbol name across several projects at once",
 			parameters: Type.Object({
 				directories: Type.Array(Type.String(), { description: "Project directories to search, each absolute or relative to the current working directory" }),
@@ -1751,7 +1788,7 @@ export default function (pi: ExtensionAPI) {
 						.join("\n");
 					return new Text(theme.fg("error", errorText || "find_symbols_across_projects failed"), 0, 0);
 				}
-				const details = result.details as { results?: readonly WorkspaceQueryOutcome<SymbolSearchResult>[] } | undefined;
+				const details = result.details as { results?: readonly CrossWorkspaceOutcome<SymbolSearchResult>[] } | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
 				text.setText(formatFindSymbolsAcrossProjectsResult(details?.results, expanded, theme));
 				return text;
@@ -1762,7 +1799,7 @@ export default function (pi: ExtensionAPI) {
 			name: "search_code_across_projects",
 			label: "Search Code Across Projects",
 			description:
-				"Fans out a ripgrep-backed text/regex search across several explicitly-named project directories at once and reports one outcome per project. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions.",
+				"Fans out a ripgrep-backed text/regex search across several explicitly-named project directories at once and reports one outcome per project. Directories are required and explicit -- never every project this daemon happens to have registered, which can include unrelated projects from other concurrent sessions. Each directory resolves to its OWN nearest project root (package.json/tsconfig.json/go.mod/Cargo.toml/...), not the outer repo's git root -- sibling packages under one monorepo stay distinct scopes rather than collapsing into one. A result's collapsedWith lists any other requested directories that genuinely did resolve to the same workspace; empty means it got its own.",
 			promptSnippet: "Search for a pattern across several projects at once",
 			parameters: Type.Object({
 				directories: Type.Array(Type.String(), { description: "Project directories to search, each absolute or relative to the current working directory" }),
@@ -1790,7 +1827,7 @@ export default function (pi: ExtensionAPI) {
 						.join("\n");
 					return new Text(theme.fg("error", errorText || "search_code_across_projects failed"), 0, 0);
 				}
-				const details = result.details as { results?: readonly WorkspaceQueryOutcome<TextSearchResult>[] } | undefined;
+				const details = result.details as { results?: readonly CrossWorkspaceOutcome<TextSearchResult>[] } | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
 				text.setText(formatSearchTextAcrossProjectsResult(details?.results, expanded, theme));
 				return text;

package/extension/src/lector-client.ts

@@ -3,6 +3,7 @@ import { dirname, extname, parse } from "node:path";
 import {
 	connectLectorClient,
 	descriptorForExtension,
+	LANGUAGE_SERVER_DESCRIPTORS,
 	type LectorClient,
 	type OperationInputs,
 	type OperationName,
@@ -142,6 +143,30 @@ export function workspaceForCodeIntelligencePath(absolutePath: string): Promise<
 	return workspaceForRoot(root);
 }
 
+/** Every known language's own rootMarkers, deduplicated -- see workspaceForProjectDirectory. */
+const ALL_PROJECT_ROOT_MARKERS: readonly string[] = [...new Set(LANGUAGE_SERVER_DESCRIPTORS.flatMap((descriptor) => descriptor.rootMarkers))];
+
+/**
+ * Resolves a caller-supplied directory to its OWN nearest project root -- never the outer repo's
+ * git root -- so distinct sibling packages under one monorepo stay distinct workspaces. Unlike
+ * workspaceForDirectory (used by find_symbols/read/write, where one canonical workspaceId per
+ * repo is exactly the point), this is for a tool whose entire premise is comparing *different*
+ * scopes (find_symbols_across_projects, search_code_across_projects): collapsing two sibling
+ * packages into the same workspaceId there silently duplicates one package's own results under
+ * the other's name, with no error at all -- confirmed live against this monorepo
+ * (packages/lector and packages/pi-lector both resolved to the same workspaceId).
+ *
+ * Unlike workspaceForCodeIntelligencePath, there is no single file (and therefore no known
+ * extension) to pick one specific language's markers from -- a caller-supplied directory could
+ * be any language, so this checks the union of every known language's rootMarkers. Falls back to
+ * the nearest git root, then the directory itself, exactly as nearestProjectRoot already does
+ * internally (it appends ".git" to whatever marker list it's given).
+ */
+export function workspaceForProjectDirectory(directory: string): Promise<ResolvedWorkspace> {
+	const root = nearestProjectRoot(directory, ALL_PROJECT_ROOT_MARKERS) ?? directory;
+	return workspaceForRoot(root);
+}
+
 /**
  * For an operation whose `path` genuinely means "the project/workspace itself"
  * (populateSymbolGraph, workspaceMap, hasWarmIndex) rather than one specific file

package/extension/src/{line-edit-operations.ts → line-edit/operations.ts}

@@ -1,12 +1,12 @@
 import { type LineEdit, type LineEditOutcome, type LineHash, lineHashOf } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForPath } from "./lector-client.ts";
-import { toWorkspaceRelativePath } from "./workspace-relative-path.ts";
+import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { toWorkspaceRelativePath } from "../workspace-relative-path.ts";
 
 /**
  * Thin wrapper over workspace.lineEdit -- distinct from the generic edit tool (backed by
- * exactEdit's whole-file hash guard, see edit-operations.ts): every edit here is guarded by
+ * exactEdit's whole-file hash guard, see edit/operations.ts): every edit here is guarded by
  * its own referenced line(s)' hash, so a concurrent change to a line no edit references never
- * invalidates this one. `path` is an absolute file path, the same convention edit-operations.ts
+ * invalidates this one. `path` is an absolute file path, the same convention edit/operations.ts
  * already uses -- the workspace is resolved from the file itself, not a separate directory arg.
  */
 export interface LineEditOperations {

package/extension/src/{line-edit-rendering.ts → line-edit/rendering.ts}

@@ -1,5 +1,5 @@
 import type { LineEditOutcome } from "@danypops/lector";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 export function formatLineEditCall(args: { path?: unknown; edits?: unknown }, theme: LectorTheme): string {
 	const path = typeof args.path === "string" ? args.path : "";

package/extension/src/{mutation-history-operations.ts → mutation-history/operations.ts}

@@ -1,6 +1,6 @@
 import type { MutationHistoryEntry } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForPath } from "./lector-client.ts";
-import { toWorkspaceRelativePath } from "./workspace-relative-path.ts";
+import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { toWorkspaceRelativePath } from "../workspace-relative-path.ts";
 
 /** Thin wrapper over Lector's mutation history: every successful edit is recorded, and any entry can be reverted -- guarded the same way every other Lector write is. */
 export interface MutationHistoryOperations {

package/extension/src/{package-source-operations.ts → package-source/operations.ts}

@@ -1,5 +1,5 @@
 import { DEFAULT_PACKAGE_SOURCE_BOUNDS, type PackageEcosystem, type PackageSourceListEntry, type PackageSourceOperationResult } from "@danypops/lector";
-import { lectorClient } from "./lector-client.ts";
+import { lectorClient } from "../lector-client.ts";
 
 export interface PackageSourceListPage {
 	readonly entries: readonly PackageSourceListEntry[];