@danypops/pi-lector 0.9.6 → 0.10.0

package/extension/src/{apply-patch-operations.ts → apply-patch/operations.ts}

@@ -1,13 +1,13 @@
 import type { ContentHash, EditOutcome } 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.applyPatch -- distinct from both the generic edit tool
  * (whole-file replace) and line_edit (per-line hash guards): applies a real unified diff's
  * hunks, guarded by one whole-file expectedHash (a patch inherently describes a
  * whole-file transformation from a known pre-image). `path` is an absolute file path, the
- * same convention edit-operations.ts and line-edit-operations.ts already use.
+ * same convention edit/operations.ts and line-edit/operations.ts already use.
  */
 export interface ApplyPatchOperations {
 	applyPatch(path: string, expectedHash: ContentHash, patchText: string): Promise<EditOutcome>;

package/extension/src/{apply-patch-rendering.ts → apply-patch/rendering.ts}

@@ -1,6 +1,6 @@
 import type { EditOutcome } from "@danypops/lector";
 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";
 
 /**
  * The applied result (EditOutcome) only carries a hash transition, not the

package/extension/src/{code-intelligence-operations.ts → code-intelligence/operations.ts}

@@ -1,5 +1,5 @@
 import type { JobSnapshot, OperationInputs, OperationOutputs, PopulateSymbolGraphResult, SymbolEdgeKind, SymbolNode } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath, workspaceForPathOrDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath, workspaceForPathOrDirectory } from "../lector-client.ts";
 
 /**
  * Thin wrappers over Lector's code-intelligence operations: goToDefinition,
@@ -39,7 +39,7 @@ export interface CodeIntelligenceOperations {
 	outgoingCalls(path: string, line: number, character: number): Promise<OperationOutputs["workspace.outgoingCalls"]>;
 	/**
 	 * Not exposed as a standalone Pi tool -- every workspace auto-populates on first touch via
-	 * monitorWorkspaceCache (workspace-cache-operations.ts). Kept here as an internal capability
+	 * monitorWorkspaceCache (workspace-cache/operations.ts). Kept here as an internal capability
 	 * for tests that need a populated graph. For an explicit/custom-bound population outside
 	 * Pi entirely, `lector workspace populate-symbol-graph` calls the daemon directly.
 	 */

package/extension/src/{code-intelligence-rendering.ts → code-intelligence/rendering.ts}

@@ -12,7 +12,7 @@ import type {
 } from "@danypops/lector";
 import { keyHint, type ThemeColor } 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 the code-intelligence tools: go_to_definition,

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

@@ -1,5 +1,5 @@
 import type { SymbolSearchResult, TextSearchResult, WorkspaceQueryOutcome } from "@danypops/lector";
-import { lectorClient, workspaceForProjectDirectory } from "./lector-client.ts";
+import { lectorClient, workspaceForProjectDirectory } from "../lector-client.ts";
 
 /**
  * Fans out across explicitly-named directories only -- never the daemon's own "every registered

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

@@ -1,9 +1,9 @@
 import type { SymbolSearchResult, TextSearchResult } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList } from "malevich-tui-components";
-import type { CrossWorkspaceOutcome } from "./cross-workspace-search-operations.ts";
-import { describeFindSymbolSources } from "./find-symbols-rendering.ts";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import { describeFindSymbolSources } from "../find-symbols/rendering.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
+import type { CrossWorkspaceOutcome } from "./operations.ts";
 
 const DEFAULT_VISIBLE_PER_WORKSPACE = 10;
 
@@ -17,9 +17,21 @@ function formatOutcomeHeader(entry: CrossWorkspaceOutcome<unknown>, theme: Lecto
 	const { outcome } = entry;
 	const label = theme.fg("accent", entry.directory);
 	const lines: string[] = [];
-	if (outcome.status === "ready") lines.push(label);
-	else if (outcome.status === "loading") lines.push(`${label} ${theme.fg("warning", `-- still loading: ${outcome.message}`)}`);
-	else lines.push(`${label} ${theme.fg("error", `-- ${outcome.message}`)}`);
+	switch (outcome.status) {
+		case "ready":
+			lines.push(label);
+			break;
+		case "loading":
+			lines.push(`${label} ${theme.fg("warning", `-- still loading: ${outcome.message}`)}`);
+			break;
+		case "error":
+			lines.push(`${label} ${theme.fg("error", `-- ${outcome.message}`)}`);
+			break;
+		default: {
+			const exhaustive: never = outcome;
+			throw new Error(`unhandled workspace query outcome status: ${JSON.stringify(exhaustive)}`);
+		}
+	}
 	// Surfaced explicitly, never silently -- two distinct inputs resolving to one workspace means
 	// one of their own result payloads below is a real duplicate of the other's, not two independent answers.
 	if (entry.collapsedWith.length > 0) {

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

@@ -1,7 +1,7 @@
 import { type ContentHash, remoteErrorIs } from "@danypops/lector";
 import type { EditOperations } from "@earendil-works/pi-coding-agent";
-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";
 
 /**
  * EditOperations backed by Lector's hash-guarded exactEdit. The workspace

package/extension/src/editor/editor-state.ts

@@ -0,0 +1,317 @@
+import { LiveBuffer } from "@danypops/lector";
+
+export type EditorMode = "normal" | "insert" | "command";
+
+export type EditorAction = { kind: "save" } | { kind: "save-and-quit" } | { kind: "quit" } | { kind: "hover" };
+
+const BACKSPACE_KEYS = new Set(["\x7f", "\b"]);
+
+/**
+ * Pure neovim-style modal editing state machine: mode transitions, cursor motion, and buffer
+ * edits, with no terminal/ANSI rendering and no I/O -- save/quit/hover requests surface as
+ * `pendingAction` for the hosting Component to actually perform (reading/writing through
+ * Lector's hash-guarded workspace operations lives outside this class entirely). Kept
+ * side-effect-free like this specifically so mode/motion/edit logic is unit-testable without a
+ * real terminal, per this environment's own "test behavior, not pixels" TUI-testing standard.
+ */
+export class EditorState {
+	buffer: LiveBuffer;
+	mode: EditorMode = "normal";
+	cursorLine = 1;
+	cursorCharacter = 1;
+	commandText = "";
+	pendingAction: EditorAction | undefined;
+	dirty = false;
+
+	private normalPrefix = "";
+	private insertPendingJ = false;
+	private yankedLine: string | undefined;
+
+	constructor(content: string) {
+		this.buffer = new LiveBuffer(content);
+	}
+
+	get currentLineText(): string {
+		return this.buffer.lineText(this.cursorLine);
+	}
+
+	handleKey(data: string): void {
+		this.pendingAction = undefined;
+		if (this.mode === "insert") {
+			this.handleInsertKey(data);
+		} else if (this.mode === "command") {
+			this.handleCommandKey(data);
+		} else {
+			this.handleNormalKey(data);
+		}
+		this.clampCursor();
+	}
+
+	private clampCursor(): void {
+		this.cursorLine = Math.min(Math.max(this.cursorLine, 1), this.buffer.lineCount);
+		const lineLength = this.currentLineText.length;
+		const maxCharacter = this.mode === "insert" ? lineLength + 1 : Math.max(lineLength, 1);
+		this.cursorCharacter = Math.min(Math.max(this.cursorCharacter, 1), maxCharacter);
+	}
+
+	private enterInsert(): void {
+		this.mode = "insert";
+		this.insertPendingJ = false;
+	}
+
+	// ── Normal mode ──────────────────────────────────────────────────────────
+
+	private handleNormalKey(data: string): void {
+		// Two-key sequences: dd, gg, yy.
+		if (this.normalPrefix) {
+			const prefix = this.normalPrefix;
+			this.normalPrefix = "";
+			if (prefix === "d" && data === "d") {
+				this.deleteCurrentLine();
+				return;
+			}
+			if (prefix === "g" && data === "g") {
+				this.cursorLine = 1;
+				return;
+			}
+			if (prefix === "y" && data === "y") {
+				this.yankedLine = this.currentLineText;
+				return;
+			}
+			// Prefix didn't complete into a known sequence -- fall through and handle `data` fresh.
+		}
+
+		switch (data) {
+			case "h":
+				this.cursorCharacter -= 1;
+				return;
+			case "l":
+				this.cursorCharacter += 1;
+				return;
+			case "k":
+				this.cursorLine -= 1;
+				return;
+			case "j":
+				this.cursorLine += 1;
+				return;
+			case "0":
+				this.cursorCharacter = 1;
+				return;
+			case "$":
+				this.cursorCharacter = Math.max(this.currentLineText.length, 1);
+				return;
+			case "G":
+				this.cursorLine = this.buffer.lineCount;
+				return;
+			case "d":
+			case "g":
+			case "y":
+				this.normalPrefix = data;
+				return;
+			case "i":
+				this.enterInsert();
+				return;
+			case "a":
+				this.cursorCharacter += 1;
+				this.enterInsert();
+				return;
+			case "I":
+				this.cursorCharacter = 1;
+				this.enterInsert();
+				return;
+			case "A":
+				this.cursorCharacter = this.currentLineText.length + 1;
+				this.enterInsert();
+				return;
+			case "o":
+				this.openLine(this.cursorLine);
+				return;
+			case "O":
+				this.openLine(this.cursorLine - 1);
+				return;
+			case "x":
+				this.deleteCharUnderCursor();
+				return;
+			case "p":
+				this.pasteYankedLine();
+				return;
+			case "u":
+				this.buffer.undo();
+				this.dirty = true;
+				return;
+			case "\x12": // Ctrl+R
+				this.buffer.redo();
+				this.dirty = true;
+				return;
+			case ":":
+				this.mode = "command";
+				this.commandText = "";
+				return;
+			case "\x13": // Ctrl+S
+				this.pendingAction = { kind: "save" };
+				return;
+			case "K":
+				this.pendingAction = { kind: "hover" };
+				return;
+			default:
+				return;
+		}
+	}
+
+	private openLine(afterLine: number): void {
+		const offset = this.buffer.offsetAt({ line: Math.max(afterLine, 1), character: this.buffer.lineText(Math.max(afterLine, 1)).length + 1 });
+		this.buffer.insert(offset, "\n");
+		this.cursorLine = Math.max(afterLine, 1) + 1;
+		this.cursorCharacter = 1;
+		this.enterInsert();
+		this.dirty = true;
+	}
+
+	private deleteCharUnderCursor(): void {
+		const line = this.currentLineText;
+		if (this.cursorCharacter > line.length) return;
+		const from = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.delete(from, from + 1);
+		this.dirty = true;
+	}
+
+	private deleteCurrentLine(): void {
+		const isLastLine = this.cursorLine === this.buffer.lineCount;
+		const from = this.buffer.offsetAt({ line: this.cursorLine, character: 1 });
+		const to = isLastLine
+			? this.buffer.offsetAt({ line: this.cursorLine, character: this.currentLineText.length + 1 })
+			: this.buffer.offsetAt({ line: this.cursorLine + 1, character: 1 });
+		this.yankedLine = this.currentLineText;
+		this.buffer.delete(from, to);
+		if (isLastLine && this.cursorLine > 1) this.cursorLine -= 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	private pasteYankedLine(): void {
+		if (this.yankedLine === undefined) return;
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.currentLineText.length + 1 });
+		this.buffer.insert(offset, `\n${this.yankedLine}`);
+		this.cursorLine += 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	// ── Insert mode ──────────────────────────────────────────────────────────
+
+	private handleInsertKey(data: string): void {
+		if (data === "\x1b") {
+			this.insertPendingJ = false;
+			this.mode = "normal";
+			this.cursorCharacter = Math.max(this.cursorCharacter - 1, 1);
+			return;
+		}
+
+		// "jk" chord exits insert without inserting either character -- mirrors the user's own
+		// real Neovim muscle memory (`map("i", "jk", "<ESC>")`).
+		if (this.insertPendingJ) {
+			this.insertPendingJ = false;
+			if (data === "k") {
+				this.mode = "normal";
+				return;
+			}
+			this.insertCharacter("j");
+			// Fall through and handle `data` normally (it wasn't the "k" half of the chord).
+		}
+		if (data === "j" && data.length === 1) {
+			this.insertPendingJ = true;
+			return;
+		}
+
+		if (BACKSPACE_KEYS.has(data)) {
+			this.backspace();
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.insertNewline();
+			return;
+		}
+		if (data.length === 1 && data.charCodeAt(0) >= 32) {
+			this.insertCharacter(data);
+			return;
+		}
+		// Unhandled control sequence (arrow keys, etc.) -- ignored in this v1 walking skeleton.
+	}
+
+	private insertCharacter(char: string): void {
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.insert(offset, char);
+		this.cursorCharacter += char.length;
+		this.dirty = true;
+	}
+
+	private insertNewline(): void {
+		const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+		this.buffer.insert(offset, "\n");
+		this.cursorLine += 1;
+		this.cursorCharacter = 1;
+		this.dirty = true;
+	}
+
+	private backspace(): void {
+		if (this.cursorCharacter > 1) {
+			const offset = this.buffer.offsetAt({ line: this.cursorLine, character: this.cursorCharacter });
+			this.buffer.delete(offset - 1, offset);
+			this.cursorCharacter -= 1;
+			this.dirty = true;
+			return;
+		}
+		if (this.cursorLine > 1) {
+			const previousLineLength = this.buffer.lineText(this.cursorLine - 1).length;
+			const offset = this.buffer.offsetAt({ line: this.cursorLine, character: 1 });
+			this.buffer.delete(offset - 1, offset);
+			this.cursorLine -= 1;
+			this.cursorCharacter = previousLineLength + 1;
+			this.dirty = true;
+		}
+	}
+
+	// ── Command mode ─────────────────────────────────────────────────────────
+
+	private handleCommandKey(data: string): void {
+		if (data === "\x1b") {
+			this.mode = "normal";
+			this.commandText = "";
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.executeCommand(this.commandText);
+			this.mode = "normal";
+			this.commandText = "";
+			return;
+		}
+		if (BACKSPACE_KEYS.has(data)) {
+			if (this.commandText.length === 0) {
+				this.mode = "normal";
+				return;
+			}
+			this.commandText = this.commandText.slice(0, -1);
+			return;
+		}
+		if (data.length === 1 && data.charCodeAt(0) >= 32) {
+			this.commandText += data;
+		}
+	}
+
+	private executeCommand(command: string): void {
+		switch (command) {
+			case "w":
+				this.pendingAction = { kind: "save" };
+				return;
+			case "q":
+				this.pendingAction = { kind: "quit" };
+				return;
+			case "wq":
+			case "x":
+				this.pendingAction = { kind: "save-and-quit" };
+				return;
+			default:
+				return;
+		}
+	}
+}

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

@@ -43,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,
@@ -66,29 +66,31 @@ import {
 	formatReachableFromResult,
 	formatWorkspaceMapCall,
 	formatWorkspaceMapResult,
-} 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 { 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,
@@ -99,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,
@@ -114,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}`;
@@ -344,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 = {

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[];

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

@@ -1,7 +1,7 @@
 import type { PackageSourceListEntry, PackageSourceOperationResult } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { renderTruncatedList, type TableColumn } from "malevich-tui-components";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 const DEFAULT_VISIBLE_CANDIDATES = 5;
 
@@ -36,33 +36,40 @@ export function formatPackageSourceCall(
 export function formatPackageSourceResult(result: PackageSourceOperationResult | undefined, expanded: boolean, theme: LectorTheme): string {
 	if (!result) return theme.fg("dim", "No package-source result.");
 	const { outcome } = result;
-	if (outcome.status === "verified") {
-		return [
-			`${theme.fg("accent", result.workspaceId ?? "unregistered")} ${theme.fg("success", `${outcome.coordinate.name}@${outcome.coordinate.resolvedVersion}`)}`,
-			`${outcome.workspace.cachePath}`,
-			`${outcome.repository.url ?? "local source"}@${outcome.repository.resolvedRef ?? "local"} ${outcome.repository.commit ?? outcome.verification.integrity}`,
-		].join("\n");
+	switch (outcome.status) {
+		case "verified":
+			return [
+				`${theme.fg("accent", result.workspaceId ?? "unregistered")} ${theme.fg("success", `${outcome.coordinate.name}@${outcome.coordinate.resolvedVersion}`)}`,
+				`${outcome.workspace.cachePath}`,
+				`${outcome.repository.url ?? "local source"}@${outcome.repository.resolvedRef ?? "local"} ${outcome.repository.commit ?? outcome.verification.integrity}`,
+			].join("\n");
+		case "ambiguous": {
+			const lines = [
+				theme.fg("warning", `Ambiguous package source (${outcome.code})`),
+				...renderTruncatedList({
+					items: outcome.candidates,
+					expanded,
+					visibleCount: DEFAULT_VISIBLE_CANDIDATES,
+					formatItem: (candidate) => `${candidate.version} -- ${candidate.source}`,
+					moreLine: (hidden) => theme.fg("dim", `… ${hidden} more`),
+					truncationWarning: outcome.truncated ? theme.fg("dim", "More candidates were truncated by the daemon.") : undefined,
+				}),
+			];
+			return lines.join("\n");
+		}
+		case "unauthenticated":
+			return theme.fg("warning", `Authentication required (${outcome.code}): configure ${outcome.requiredCredentialNames.join(", ")}`);
+		case "oversized":
+			return theme.fg("warning", `Source resolution exceeded ${outcome.resource} limit ${outcome.limit}.`);
+		case "mismatched":
+			return theme.fg("error", `Source mismatch (${outcome.code}): expected ${outcome.expected}, got ${outcome.actual}.`);
+		case "unavailable":
+			return theme.fg("warning", `Source unavailable (${outcome.code}).`);
+		default: {
+			const exhaustive: never = outcome;
+			throw new Error(`unhandled package source outcome status: ${JSON.stringify(exhaustive)}`);
+		}
 	}
-	if (outcome.status === "ambiguous") {
-		const lines = [
-			theme.fg("warning", `Ambiguous package source (${outcome.code})`),
-			...renderTruncatedList({
-				items: outcome.candidates,
-				expanded,
-				visibleCount: DEFAULT_VISIBLE_CANDIDATES,
-				formatItem: (candidate) => `${candidate.version} -- ${candidate.source}`,
-				moreLine: (hidden) => theme.fg("dim", `… ${hidden} more`),
-				truncationWarning: outcome.truncated ? theme.fg("dim", "More candidates were truncated by the daemon.") : undefined,
-			}),
-		];
-		return lines.join("\n");
-	}
-	if (outcome.status === "unauthenticated") {
-		return theme.fg("warning", `Authentication required (${outcome.code}): configure ${outcome.requiredCredentialNames.join(", ")}`);
-	}
-	if (outcome.status === "oversized") return theme.fg("warning", `Source resolution exceeded ${outcome.resource} limit ${outcome.limit}.`);
-	if (outcome.status === "mismatched") return theme.fg("error", `Source mismatch (${outcome.code}): expected ${outcome.expected}, got ${outcome.actual}.`);
-	return theme.fg("warning", `Source unavailable (${outcome.code}).`);
 }
 
 /** Empty-state fallback only -- a non-empty page renders as a real Table (see buildPackageSourceListTableRows) so the human channel actually shows what's resolved, not just a bare count. Mirrors formatRepoCacheListResult. */
@@ -74,7 +81,7 @@ export function formatPackageSourceListResult(
 	return count === 0 ? theme.fg("dim", "no resolved package sources") : theme.fg("success", `${count} resolved package source${count === 1 ? "" : "s"}`);
 }
 
-/** Powers of 1024, one decimal past the first. Mirrors repo-cache-rendering.ts's own formatCacheSize -- kept as a small local duplicate rather than a shared export, matching that file's own precedent. */
+/** Powers of 1024, one decimal past the first. Mirrors repo-cache/rendering.ts's own formatCacheSize -- kept as a small local duplicate rather than a shared export, matching that file's own precedent. */
 function formatCacheSize(bytes: number): string {
 	const units = ["B", "KB", "MB", "GB", "TB"] as const;
 	let value = bytes;

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

@@ -1,8 +1,8 @@
 import { constants } from "node:fs";
 import { access as fsAccess, readFile as fsReadFile } from "node:fs/promises";
 import type { ReadOperations } from "@earendil-works/pi-coding-agent";
-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";
 
 /**
  * Lector's core domain (RawRead/ExpectedHashEdit) is deliberately text-only

package/extension/src/{reference-based-rename-operations.ts → reference-based-rename/operations.ts}

@@ -1,5 +1,5 @@
 import type { OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "../lector-client.ts";
 
 /**
  * Thin wrapper over Lector's non-LSP reference-based rename: moves a file and rewrites every

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

@@ -1,5 +1,5 @@
 import type { OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "../lector-client.ts";
 
 /**
  * Thin wrappers over Lector's LSP-driven prepareRename/rename -- position-based (path + 1-indexed

package/extension/src/{repo-cache-evict-operations.ts → repo-cache/evict-operations.ts}

@@ -1,8 +1,8 @@
-import { lectorClient } from "./lector-client.ts";
+import { lectorClient } from "../lector-client.ts";
 
 /**
  * Thin wrapper over repo.evictCache -- no `directory`/workspaceForDirectory resolution (matching
- * repo-fetch-operations.ts and repo-cache-list-operations.ts: this targets the daemon-wide fetch
+ * repo-fetch/operations.ts and repo-cache/list-operations.ts: this targets the daemon-wide fetch
  * cache, not a workspace-scoped concept).
  */
 export interface RepoCacheEvictOperations {

package/extension/src/{repo-cache-list-operations.ts → repo-cache/list-operations.ts}

@@ -1,9 +1,9 @@
 import type { CachedRepositoryPage } from "@danypops/lector";
-import { lectorClient } from "./lector-client.ts";
+import { lectorClient } from "../lector-client.ts";
 
 /**
  * Thin wrapper over repo.listCache -- no network, no cache mutation, no `directory`/
- * workspaceForDirectory resolution (matching repo-fetch-operations.ts: this queries the
+ * workspaceForDirectory resolution (matching repo-fetch/operations.ts: this queries the
  * daemon-wide fetch cache, not a workspace-scoped concept).
  */
 export interface RepoCacheListOperations {

package/extension/src/{repo-cache-rendering.ts → repo-cache/rendering.ts}

@@ -1,7 +1,7 @@
 import type { CachedRepositoryEntry, CachedRepositoryPage, RepoFetchResult } from "@danypops/lector";
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import type { TableColumn } from "malevich-tui-components";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 /** Table has no row-count bound of its own; a cache can grow arbitrarily large even though repo_cache's own `maxResults` bounds any one page, so the display itself still needs a cap independent of that. */
 export const REPO_CACHE_VISIBLE_ROWS = 20;

package/extension/src/{repo-fetch-operations.ts → repo-fetch/operations.ts}

@@ -1,5 +1,5 @@
 import type { RepoFetchResult } from "@danypops/lector";
-import { lectorClient } from "./lector-client.ts";
+import { lectorClient } from "../lector-client.ts";
 
 /**
  * Thin wrapper over repo.fetch. No `directory`/workspaceForDirectory resolution here -- unlike

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

@@ -1,5 +1,5 @@
 import type { TextSearchResult } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
 
 /**
  * Thin wrapper over workspace.searchText. `directory` is required, same convention as

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

@@ -1,7 +1,7 @@
 import type { TextSearchResult } 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_MATCHES = 20;
 

package/extension/src/{symbol-annotation-operations.ts → symbol-annotation/operations.ts}

@@ -1,5 +1,5 @@
 import type { OperationInputs, OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForCodeIntelligencePath } from "../lector-client.ts";
 
 /** A bare symbol position an anchor is given as -- symbolNodeId and the anchor's baseline file hash are derived server-side, never supplied by the caller. */
 export interface AnnotationAnchorInput {

package/extension/src/{symbol-annotation-rendering.ts → symbol-annotation/rendering.ts}

@@ -1,5 +1,5 @@
 import type { SymbolAnnotation } from "@danypops/lector";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 const STATUS_COLOR: Record<SymbolAnnotation["status"], "success" | "warning" | "dim"> = {
 	fresh: "success",

package/extension/src/{workspace-cache-operations.ts → workspace-cache/operations.ts}

@@ -1,5 +1,5 @@
 import type { JobSnapshot, PopulateSymbolGraphResult, WorkspaceCacheStatus } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForDirectory } from "./lector-client.ts";
+import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
 
 export interface WorkspaceCacheOperations {
 	status(directory: string, maxFiles: number, maxSymbolsPerFile: number): Promise<WorkspaceCacheStatus>;

package/extension/src/{workspace-cache-rendering.ts → workspace-cache/rendering.ts}

@@ -1,5 +1,5 @@
 import type { JobSnapshot, PopulateSymbolGraphResult, WorkspaceCacheStatus } from "@danypops/lector";
-import type { LectorTheme } from "./lector-tui-theme.ts";
+import type { LectorTheme } from "../lector-tui-theme.ts";
 
 type WorkspaceCacheAction = "status" | "populate" | "job_status";
 

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

@@ -1,7 +1,7 @@
 import { type ContentHash, remoteErrorIs } from "@danypops/lector";
 import type { WriteOperations } from "@earendil-works/pi-coding-agent";
-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";
 
 const MAX_STALE_HASH_RETRIES = 3;
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.9.6",
+	"version": "0.10.0",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -19,7 +19,7 @@
 	},
 	"dependencies": {
 		"@danypops/vehicle-client": "^0.2.0",
-		"@danypops/lector": "^0.12.0",
+		"@danypops/lector": "^0.14.0",
 		"malevich-tui-components": "^0.19.0"
 	},
 	"devDependencies": {