@danypops/pi-lector 0.12.9 → 0.12.11

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

@@ -62,7 +62,7 @@ export class EditorState {
 	// ── Normal mode ──────────────────────────────────────────────────────────
 
 	private handleNormalKey(data: string): void {
-		// Two-key sequences: dd, gg, yy.
+		// Two-key sequences: dd, gg, yy, ZZ, ZQ.
 		if (this.normalPrefix) {
 			const prefix = this.normalPrefix;
 			this.normalPrefix = "";
@@ -78,6 +78,18 @@ export class EditorState {
 				this.yankedLine = this.currentLineText;
 				return;
 			}
+			// Real vim's own close-on-demand mnemonics -- ZZ saves and quits (equivalent to :wq),
+			// ZQ quits without saving (equivalent to :q). Added so a host never needs to invent its
+			// own dismiss keybinding or reach into this class's internal mode/dirty state -- the
+			// editor decides its own exit paths, exactly like :q/:wq already do.
+			if (prefix === "Z" && data === "Z") {
+				this.pendingAction = { kind: "save-and-quit" };
+				return;
+			}
+			if (prefix === "Z" && data === "Q") {
+				this.pendingAction = { kind: "quit" };
+				return;
+			}
 			// Prefix didn't complete into a known sequence -- fall through and handle `data` fresh.
 		}
 
@@ -106,6 +118,7 @@ export class EditorState {
 			case "d":
 			case "g":
 			case "y":
+			case "Z":
 				this.normalPrefix = data;
 				return;
 			case "i":

package/extension/src/editor/index.ts

@@ -15,8 +15,27 @@
  * construct and mount a real Lector editor Component directly, against its own tui/theme
  * implementation and its own ModalEditorHost backed by whatever it wants (a Lector daemon
  * client, a Vehicle operation, a plain filesystem call -- this package doesn't care).
+ *
+ * The same holds for ExplorerComponent (the oil.nvim-style directory explorer, built on the same
+ * EditorState engine): it only depends on `tui`/`theme` plus a DirectoryExplorerSession, its own
+ * real external contract. DirectoryExplorerSession happens to be declared alongside
+ * openDirectoryExplorer in directory-explorer-operations.ts, but the two are not the same kind of
+ * thing -- exactly the ModalEditorHost/openEditorFile split repeats here. openDirectoryExplorer
+ * (and openEditorFile) are this package's OWN Pi-extension-internal construction helpers, built on
+ * this package's own lectorClient()/withWorkspace -- deliberately not exported. A real external
+ * host is expected to supply its own DirectoryExplorerSession implementation, backed by whatever
+ * it wants, the same way Alignment's own ModalEditorHost implementation never reuses
+ * openEditorFile either.
  */
 
+export type { DirectoryExplorerSession } from "./directory-explorer-operations.ts";
 export { type EditorAction, type EditorMode, EditorState } from "./editor-state.ts";
 export type { EditorTheme } from "./editor-theme.ts";
+export { ExplorerComponent, type ExplorerResult, joinExplorerPath } from "./explorer-component.ts";
+// runExplorerFlow is pure orchestration over the two interfaces above (browse, open a file into
+// the real editor, return to the explorer at that file's own directory once it quits) -- exported
+// for the same reason ExplorerComponent/DirectoryExplorerSession are: any real host can drive this
+// exact, already-tested loop without re-deriving it, instead of only this package's own Pi
+// extension entry point being able to.
+export { type ExplorerFlowHost, runExplorerFlow } from "./explorer-flow.ts";
 export { ModalEditorComponent, type ModalEditorHost } from "./modal-editor-component.ts";

package/extension/src/external-search/operations.ts

@@ -1,26 +1,40 @@
 import type { GithubRepoSearchResult, NpmPackageCandidate, SourcegraphCodeCandidate } from "@danypops/lector";
-import { lectorClient } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-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. */
+/** Matches EXTERNAL_SEARCH_PERMISSIONS' own declared value server-side (external-search/operation-registration.ts). */
+const EXTERNAL_SEARCH_PERMISSIONS = ["external-search:read"];
+
+/**
+ * Thin wrapper over search.githubRepos/search.npmPackages/search.sourcegraphCode, dispatched
+ * through invokeVehicleOperation -- explicit-query discovery inputs shaped for
+ * repo_cache/package_source, never open-ended discovery/trending.
+ */
 export interface ExternalSearchOperations {
-	githubRepos(query: string, maxResults: number): Promise<GithubRepoSearchResult>;
-	npmPackages(query: string, maxResults: number): Promise<{ candidates: readonly NpmPackageCandidate[] }>;
-	sourcegraphCode(query: string, maxResults: number): Promise<{ candidates: readonly SourcegraphCodeCandidate[] }>;
+	githubRepos(query: string, maxResults: number, call: LectorVehicleCall): Promise<GithubRepoSearchResult>;
+	npmPackages(query: string, maxResults: number, call: LectorVehicleCall): Promise<{ candidates: readonly NpmPackageCandidate[] }>;
+	sourcegraphCode(query: string, maxResults: number, call: LectorVehicleCall): Promise<{ candidates: readonly SourcegraphCodeCandidate[] }>;
 }
 
 export function createExternalSearchOperations(): ExternalSearchOperations {
 	return {
-		async githubRepos(query, maxResults) {
-			const client = await lectorClient();
-			return client.call("search.githubRepos", { query, maxResults });
+		githubRepos(query, maxResults, call) {
+			return invokeLectorVehicleOperation<GithubRepoSearchResult>("search.githubRepos", { query, maxResults }, EXTERNAL_SEARCH_PERMISSIONS, call);
 		},
-		async npmPackages(query, maxResults) {
-			const client = await lectorClient();
-			return client.call("search.npmPackages", { query, maxResults });
+		npmPackages(query, maxResults, call) {
+			return invokeLectorVehicleOperation<{ candidates: readonly NpmPackageCandidate[] }>(
+				"search.npmPackages",
+				{ query, maxResults },
+				EXTERNAL_SEARCH_PERMISSIONS,
+				call,
+			);
 		},
-		async sourcegraphCode(query, maxResults) {
-			const client = await lectorClient();
-			return client.call("search.sourcegraphCode", { query, maxResults });
+		sourcegraphCode(query, maxResults, call) {
+			return invokeLectorVehicleOperation<{ candidates: readonly SourcegraphCodeCandidate[] }>(
+				"search.sourcegraphCode",
+				{ query, maxResults },
+				EXTERNAL_SEARCH_PERMISSIONS,
+				call,
+			);
 		},
 	};
 }

package/extension/src/git/operations.ts

@@ -1,48 +1,57 @@
 import type { GitDiffResult, GitLogEntry, GitStatusSummary, OperationOutputs } from "@danypops/lector";
 import { lectorClient, withWorkspace, workspaceForDirectory } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
 
 type SymbolComparison = OperationOutputs["workspace.compareSymbolAcrossVersions"];
 
+/** Matches GIT_READ_PERMISSIONS' own declared value server-side (git/operation-registration.ts). */
+const GIT_READ_PERMISSIONS = ["workspace:read"];
+
 /**
  * Thin wrappers over Lector's read-only git operations. `directory` is
  * required, same convention as find_symbols -- no implicit "whatever the
  * session's cwd is" fallback.
+ *
+ * status/log/diff dispatch through invokeLectorVehicleOperation (the real VehicleRegistry-backed
+ * workspace.gitStatus/gitLog/gitDiff operations -- see Lector Phase 1/2 of the vehicle-client-pi
+ * adoption epic) instead of a bare lectorClient().call(), gaining activity broadcasting, the
+ * local /safety ask gate, and idempotency-key/correlationId derivation for free. compareSymbol
+ * (workspace.compareSymbolAcrossVersions) has not migrated onto VehicleRegistry server-side yet,
+ * so it stays on the legacy dispatch unchanged.
  */
 export interface GitOperations {
-	status(directory: string): Promise<GitStatusSummary>;
-	log(directory: string, maxCount: number): Promise<readonly GitLogEntry[]>;
-	diff(directory: string, ref: string | undefined, maxBytes: number): Promise<GitDiffResult>;
+	status(directory: string, call: LectorVehicleCall): Promise<GitStatusSummary>;
+	log(directory: string, maxCount: number, call: LectorVehicleCall): Promise<readonly GitLogEntry[]>;
+	diff(directory: string, ref: string | undefined, maxBytes: number, call: LectorVehicleCall): Promise<GitDiffResult>;
 	compareSymbol(directory: string, path: string, symbolName: string, fromRef: string, toRef: string | undefined, maxBytes: number): Promise<SymbolComparison>;
 }
 
 export function createLectorGitOperations(): GitOperations {
 	return {
-		async status(directory) {
+		async status(directory, call) {
 			return withWorkspace(
 				() => workspaceForDirectory(directory),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.call("workspace.gitStatus", { workspaceId });
-				},
+				({ workspaceId }) => invokeLectorVehicleOperation<GitStatusSummary>("workspace.gitStatus", { workspaceId }, GIT_READ_PERMISSIONS, call),
 			);
 		},
-		async log(directory, maxCount) {
+		async log(directory, maxCount, call) {
 			return withWorkspace(
 				() => workspaceForDirectory(directory),
 				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					const { entries } = await client.call("workspace.gitLog", { workspaceId, maxCount });
+					const { entries } = await invokeLectorVehicleOperation<{ entries: readonly GitLogEntry[] }>(
+						"workspace.gitLog",
+						{ workspaceId, maxCount },
+						GIT_READ_PERMISSIONS,
+						call,
+					);
 					return entries;
 				},
 			);
 		},
-		async diff(directory, ref, maxBytes) {
+		async diff(directory, ref, maxBytes, call) {
 			return withWorkspace(
 				() => workspaceForDirectory(directory),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.call("workspace.gitDiff", { workspaceId, ref, maxBytes });
-				},
+				({ workspaceId }) => invokeLectorVehicleOperation<GitDiffResult>("workspace.gitDiff", { workspaceId, ref, maxBytes }, GIT_READ_PERMISSIONS, call),
 			);
 		},
 		async compareSymbol(directory, path, symbolName, fromRef, toRef, maxBytes) {

package/extension/src/index.ts

@@ -128,6 +128,7 @@ 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 { LectorVehicleCall } from "./vehicle-client.ts";
 import {
 	type CachePresentationState,
 	cacheContextMessage,
@@ -906,30 +907,42 @@ export default function (pi: ExtensionAPI) {
 				rootId: Type.Optional(Type.String({ description: "The subtree's root annotation id -- required for tree" })),
 				maxDepth: Type.Optional(Type.Number({ description: "Maximum containment hops from rootId to include -- required for tree" })),
 			}),
-			async execute(_toolCallId, params) {
+			async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<SymbolAnnotationToolDetails>> {
 				const path = resolve(cwd, params.path);
+				const vehicleCall: LectorVehicleCall = {
+					toolName: "symbol_annotations",
+					toolCallId,
+					signal,
+					context: ctx,
+				};
 				const details: SymbolAnnotationToolDetails = {};
 				let text: string;
 				if (params.action === "create") {
 					if (!params.subtype || !params.title || params.body === undefined || !params.anchors || params.anchors.length === 0) {
 						throw new Error("symbol_annotations create requires subtype, title, body, and at least one anchor");
 					}
-					const { annotation } = await symbolAnnotationOperations.create(path, params.subtype, params.title, params.body, resolveAnchorInputs(params.anchors));
+					const { annotation } = await symbolAnnotationOperations.create(
+						path,
+						params.subtype,
+						params.title,
+						params.body,
+						resolveAnchorInputs(params.anchors),
+						vehicleCall,
+					);
 					details.annotation = annotation;
 					text = formatAnnotationDetail(annotation);
 				} else if (params.action === "get") {
 					if (!params.id) throw new Error("symbol_annotations get requires id");
-					const { annotation } = await symbolAnnotationOperations.get(path, params.id);
+					const { annotation } = await symbolAnnotationOperations.get(path, params.id, vehicleCall);
 					details.annotation = annotation;
 					text = annotation ? formatAnnotationDetail(annotation) : `no annotation "${params.id}"`;
 				} else if (params.action === "list") {
 					const status = params.listStatus === "fresh" || params.listStatus === "stale" || params.listStatus === "scrubbed" ? params.listStatus : undefined;
-					const { annotations } = await symbolAnnotationOperations.list(path, {
-						subtype: params.listSubtype,
-						status,
-						maxResults: params.maxResults,
-						query: params.listQuery,
-					});
+					const { annotations } = await symbolAnnotationOperations.list(
+						path,
+						{ subtype: params.listSubtype, status, maxResults: params.maxResults, query: params.listQuery },
+						vehicleCall,
+					);
 					details.annotations = annotations;
 					text = annotations.length === 0 ? "no annotations" : annotations.map(formatAnnotationDetail).join("\n\n");
 				} else if (params.action === "refresh") {
@@ -943,32 +956,33 @@ export default function (pi: ExtensionAPI) {
 						params.title,
 						params.body,
 						resolveAnchorInputs(params.anchors),
+						vehicleCall,
 					);
 					details.annotation = annotation;
 					text = annotation ? formatAnnotationDetail(annotation) : `no annotation "${params.id}"`;
 				} else if (params.action === "scrub") {
 					if (!params.id) throw new Error("symbol_annotations scrub requires id");
-					const { scrubbed } = await symbolAnnotationOperations.scrub(path, params.id);
+					const { scrubbed } = await symbolAnnotationOperations.scrub(path, params.id, vehicleCall);
 					details.scrubbed = scrubbed;
 					text = scrubbed ? `scrubbed ${params.id}` : `"${params.id}" was already scrubbed or does not exist`;
 				} else if (params.action === "restore") {
 					if (!params.id) throw new Error("symbol_annotations restore requires id");
-					const { restored } = await symbolAnnotationOperations.restore(path, params.id);
+					const { restored } = await symbolAnnotationOperations.restore(path, params.id, vehicleCall);
 					details.restored = restored;
 					text = restored ? `restored ${params.id}` : `"${params.id}" was not scrubbed or does not exist`;
 				} else if (params.action === "contain") {
 					if (!params.parentId || !params.childId) throw new Error("symbol_annotations contain requires parentId and childId");
-					const { contained } = await symbolAnnotationOperations.contain(path, params.parentId, params.childId);
+					const { contained } = await symbolAnnotationOperations.contain(path, params.parentId, params.childId, vehicleCall);
 					details.contained = contained;
 					text = `"${params.parentId}" now contains "${params.childId}"`;
 				} else if (params.action === "uncontain") {
 					if (!params.parentId || !params.childId) throw new Error("symbol_annotations uncontain requires parentId and childId");
-					const { uncontained } = await symbolAnnotationOperations.uncontain(path, params.parentId, params.childId);
+					const { uncontained } = await symbolAnnotationOperations.uncontain(path, params.parentId, params.childId, vehicleCall);
 					details.uncontained = uncontained;
 					text = uncontained ? `"${params.parentId}" no longer contains "${params.childId}"` : `"${params.parentId}" did not contain "${params.childId}"`;
 				} else if (params.action === "tree") {
 					if (!params.rootId || params.maxDepth === undefined) throw new Error("symbol_annotations tree requires rootId and maxDepth");
-					const { annotations } = await symbolAnnotationOperations.tree(path, params.rootId, params.maxDepth);
+					const { annotations } = await symbolAnnotationOperations.tree(path, params.rootId, params.maxDepth, vehicleCall);
 					details.annotations = annotations;
 					text = annotations.length === 0 ? `no annotation "${params.rootId}"` : annotations.map(formatAnnotationDetail).join("\n\n");
 				} else {
@@ -1253,16 +1267,17 @@ export default function (pi: ExtensionAPI) {
 					Type.String({ description: "Git ref for the 'after' version; omit to compare against the current working tree -- action=compare-symbol only" }),
 				),
 			}),
-			async execute(_toolCallId, params) {
+			async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<GitToolDetails>> {
 				const directory = resolve(cwd, params.directory);
+				const vehicleCall: LectorVehicleCall = { toolName: "git", toolCallId, signal, context: ctx };
 				if (params.action === "status") {
-					const summary = await gitOperations.status(directory);
+					const summary = await gitOperations.status(directory, vehicleCall);
 					const details: GitToolDetails = { action: "status", summary };
 					return { content: [{ type: "text", text: JSON.stringify(summary) }], details };
 				}
 				if (params.action === "log") {
 					if (params.maxCount === undefined) throw new Error("git action=log requires maxCount");
-					const entries = await gitOperations.log(directory, params.maxCount);
+					const entries = await gitOperations.log(directory, params.maxCount, vehicleCall);
 					const text =
 						entries.length === 0 ? "No commits found." : entries.map((e) => `${e.sha.slice(0, 8)} ${e.authoredAt} ${e.authorName} -- ${e.message}`).join("\n");
 					const details: GitToolDetails = { action: "log", entries };
@@ -1270,7 +1285,7 @@ export default function (pi: ExtensionAPI) {
 				}
 				if (params.action === "diff") {
 					if (params.maxBytes === undefined) throw new Error("git action=diff requires maxBytes");
-					const result = await gitOperations.diff(directory, params.ref, params.maxBytes);
+					const result = await gitOperations.diff(directory, params.ref, params.maxBytes, vehicleCall);
 					const details: GitToolDetails = { action: "diff", result };
 					return { content: [{ type: "text", text: result.diff.length === 0 ? "No differences." : result.diff }], details };
 				}
@@ -1529,11 +1544,17 @@ export default function (pi: ExtensionAPI) {
 				maxResults: Type.Optional(Type.Number({ description: "Required for action=list -- maximum entries to return, newest first" })),
 				entryId: Type.Optional(Type.String({ description: "Required for action=revert -- an id returned by a prior action=list" })),
 			}),
-			async execute(_toolCallId, params): Promise<AgentToolResult<MutationHistoryToolDetails>> {
+			async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<MutationHistoryToolDetails>> {
 				const absolutePath = resolve(cwd, params.path);
+				const vehicleCall: LectorVehicleCall = {
+					toolName: "mutation_history",
+					toolCallId,
+					signal,
+					context: ctx,
+				};
 				if (params.action === "list") {
 					if (params.maxResults === undefined) throw new Error("mutation_history action=list requires maxResults");
-					const entries = await mutationHistoryOperations.list(absolutePath, params.maxResults);
+					const entries = await mutationHistoryOperations.list(absolutePath, params.maxResults, vehicleCall);
 					const text =
 						entries.length === 0
 							? "no recorded mutation history for this path"
@@ -1541,7 +1562,7 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text", text }], details: { action: "list", entries } };
 				}
 				if (params.entryId === undefined) throw new Error("mutation_history action=revert requires entryId");
-				const reverted = await mutationHistoryOperations.revert(absolutePath, params.entryId);
+				const reverted = await mutationHistoryOperations.revert(absolutePath, params.entryId, vehicleCall);
 				return {
 					content: [{ type: "text", text: `${reverted.path} reverted -> ${reverted.newHash ?? "(deleted)"}` }],
 					details: { action: "revert", reverted },
@@ -1711,15 +1732,28 @@ export default function (pi: ExtensionAPI) {
 				maxResults: Type.Optional(Type.Number({ description: "Required for action=list -- maximum entries to return in this page" })),
 				cursor: Type.Optional(Type.String({ description: "action=list only -- opaque cursor from a prior call's nextCursor, to fetch the next page" })),
 			}),
-			async execute(_toolCallId, params): Promise<AgentToolResult<RepoCacheToolDetails>> {
+			async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<RepoCacheToolDetails>> {
+				const vehicleCall: LectorVehicleCall = {
+					toolName: "repo_cache",
+					toolCallId,
+					signal,
+					context: ctx,
+				};
 				if (params.action === "fetch") {
 					if (!params.owner || !params.repo) throw new Error("repo_cache action=fetch requires owner and repo");
-					const result = await repoFetchOperations.fetch(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null, params.forceRefresh);
+					const result = await repoFetchOperations.fetch(
+						params.host ?? "github.com",
+						params.owner,
+						params.repo,
+						params.ref ?? null,
+						params.forceRefresh,
+						vehicleCall,
+					);
 					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "fetch", result } };
 				}
 				if (params.action === "evict") {
 					if (!params.owner || !params.repo) throw new Error("repo_cache action=evict requires owner and repo");
-					const result = await repoCacheEvictOperations.evict(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null);
+					const result = await repoCacheEvictOperations.evict(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null, vehicleCall);
 					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "evict", result } };
 				}
 				if (params.maxResults === undefined) throw new Error("repo_cache action=list requires maxResults");
@@ -1727,6 +1761,7 @@ export default function (pi: ExtensionAPI) {
 					{ text: params.text, host: params.host, owner: params.owner, repo: params.repo, ref: params.ref },
 					params.maxResults,
 					params.cursor,
+					vehicleCall,
 				);
 				return { content: [{ type: "text", text: JSON.stringify(page) }], details: { action: "list", page } };
 			},
@@ -1791,17 +1826,23 @@ export default function (pi: ExtensionAPI) {
 				}),
 				maxResults: Type.Optional(Type.Number({ description: "Maximum candidates to return (default 20)" })),
 			}),
-			async execute(_toolCallId, params): Promise<AgentToolResult<ExternalSearchToolDetails>> {
+			async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<ExternalSearchToolDetails>> {
 				const maxResults = params.maxResults ?? DEFAULT_EXTERNAL_SEARCH_MAX_RESULTS;
+				const vehicleCall: LectorVehicleCall = {
+					toolName: "external_search",
+					toolCallId,
+					signal,
+					context: ctx,
+				};
 				if (params.action === "github_repos") {
-					const result = await externalSearchOperations.githubRepos(params.query, maxResults);
+					const result = await externalSearchOperations.githubRepos(params.query, maxResults, vehicleCall);
 					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "github_repos", result } };
 				}
 				if (params.action === "npm_packages") {
-					const result = await externalSearchOperations.npmPackages(params.query, maxResults);
+					const result = await externalSearchOperations.npmPackages(params.query, maxResults, vehicleCall);
 					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "npm_packages", result } };
 				}
-				const result = await externalSearchOperations.sourcegraphCode(params.query, maxResults);
+				const result = await externalSearchOperations.sourcegraphCode(params.query, maxResults, vehicleCall);
 				return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "sourcegraph_code", result } };
 			},
 			renderCall(args, theme, context) {

package/extension/src/mutation-history/operations.ts

@@ -1,33 +1,49 @@
 import type { MutationHistoryEntry } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { withWorkspace, workspaceForPath } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-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. */
+/** Match MUTATION_HISTORY_READ_PERMISSIONS/MUTATION_HISTORY_WRITE_PERMISSIONS' own declared values server-side (mutation-history/operation-registration.ts). */
+const MUTATION_HISTORY_READ_PERMISSIONS = ["workspace:read"];
+const MUTATION_HISTORY_WRITE_PERMISSIONS = ["workspace:write"];
+
+/**
+ * Thin wrapper over Lector's mutation history, dispatched through invokeLectorVehicleOperation:
+ * every successful edit is recorded, and any entry can be reverted -- guarded the same way every
+ * other Lector write is.
+ */
 export interface MutationHistoryOperations {
-	list(absolutePath: string, maxResults: number): Promise<readonly MutationHistoryEntry[]>;
-	revert(absolutePath: string, entryId: string): Promise<{ path: string; newHash: string | null }>;
+	list(absolutePath: string, maxResults: number, call: LectorVehicleCall): Promise<readonly MutationHistoryEntry[]>;
+	revert(absolutePath: string, entryId: string, call: LectorVehicleCall): Promise<{ path: string; newHash: string | null }>;
 }
 
 export function createMutationHistoryOperations(): MutationHistoryOperations {
 	return {
-		list(absolutePath, maxResults) {
+		list(absolutePath, maxResults, call) {
 			return withWorkspace(
 				() => workspaceForPath(absolutePath),
 				async ({ workspaceId, root }) => {
-					const client = await lectorClient();
 					const path = toWorkspaceRelativePath(root, absolutePath);
-					const { entries } = await client.call("workspace.mutationHistory", { workspaceId, path, maxResults });
+					const { entries } = await invokeLectorVehicleOperation<{ entries: readonly MutationHistoryEntry[] }>(
+						"workspace.mutationHistory",
+						{ workspaceId, path, maxResults },
+						MUTATION_HISTORY_READ_PERMISSIONS,
+						call,
+					);
 					return entries;
 				},
 			);
 		},
-		revert(absolutePath, entryId) {
+		revert(absolutePath, entryId, call) {
 			return withWorkspace(
 				() => workspaceForPath(absolutePath),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.revertMutation", { workspaceId, entryId });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<{ path: string; newHash: string | null }>(
+						"workspace.revertMutation",
+						{ workspaceId, entryId },
+						MUTATION_HISTORY_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
 	};

package/extension/src/repo-cache/evict-operations.ts

@@ -1,19 +1,22 @@
-import { lectorClient } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
+
+/** Matches REPO_WRITE_PERMISSIONS' own declared value server-side (repo-fetcher/operation-registration.ts). */
+const REPO_WRITE_PERMISSIONS = ["workspace:write"];
 
 /**
- * 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
- * cache, not a workspace-scoped concept).
+ * Thin wrapper over repo.evictCache, dispatched through invokeVehicleOperation -- no
+ * `directory`/workspaceForDirectory resolution (matching 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 {
-	evict(host: string, owner: string, repo: string, ref: string | null): Promise<{ evicted: boolean }>;
+	evict(host: string, owner: string, repo: string, ref: string | null, call: LectorVehicleCall): Promise<{ evicted: boolean }>;
 }
 
 export function createRepoCacheEvictOperations(): RepoCacheEvictOperations {
 	return {
-		async evict(host, owner, repo, ref) {
-			const client = await lectorClient();
-			return client.callOnce("repo.evictCache", { host, owner, repo, ref });
+		evict(host, owner, repo, ref, call) {
+			return invokeLectorVehicleOperation<{ evicted: boolean }>("repo.evictCache", { host, owner, repo, ref }, REPO_WRITE_PERMISSIONS, call);
 		},
 	};
 }

package/extension/src/repo-cache/list-operations.ts

@@ -1,24 +1,28 @@
 import type { CachedRepositoryPage } from "@danypops/lector";
-import { lectorClient } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
+
+/** Matches REPO_LIST_CACHE_PERMISSIONS' own declared value server-side (repo-fetcher/operation-registration.ts). */
+const REPO_LIST_CACHE_PERMISSIONS = ["workspace:read"];
 
 /**
- * Thin wrapper over repo.listCache -- no network, no cache mutation, no `directory`/
- * workspaceForDirectory resolution (matching repo-fetch/operations.ts: this queries the
- * daemon-wide fetch cache, not a workspace-scoped concept).
+ * Thin wrapper over repo.listCache, dispatched through invokeVehicleOperation -- no network, no
+ * cache mutation, no `directory`/workspaceForDirectory resolution (matching
+ * repo-fetch/operations.ts: this queries the daemon-wide fetch cache, not a workspace-scoped
+ * concept).
  */
 export interface RepoCacheListOperations {
 	list(
 		filters: { text?: string; host?: string; owner?: string; repo?: string; ref?: string },
 		maxResults: number,
-		cursor?: string,
+		cursor: string | undefined,
+		call: LectorVehicleCall,
 	): Promise<CachedRepositoryPage>;
 }
 
 export function createRepoCacheListOperations(): RepoCacheListOperations {
 	return {
-		async list(filters, maxResults, cursor) {
-			const client = await lectorClient();
-			return client.call("repo.listCache", { ...filters, maxResults, cursor });
+		list(filters, maxResults, cursor, call) {
+			return invokeLectorVehicleOperation<CachedRepositoryPage>("repo.listCache", { ...filters, maxResults, cursor }, REPO_LIST_CACHE_PERMISSIONS, call);
 		},
 	};
 }

package/extension/src/repo-fetch/operations.ts

@@ -1,20 +1,36 @@
 import type { RepoFetchResult } from "@danypops/lector";
-import { lectorClient } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
+
+/** Matches REPO_WRITE_PERMISSIONS' own declared value server-side (repo-fetcher/operation-registration.ts). */
+const REPO_WRITE_PERMISSIONS = ["workspace:write"];
 
 /**
- * Thin wrapper over repo.fetch. No `directory`/workspaceForDirectory resolution here -- unlike
+ * Thin wrapper over repo.fetch, dispatched through invokeVehicleOperation (the real
+ * VehicleRegistry-backed operation -- see Lector's vehicle-client-pi adoption epic) instead of a
+ * bare lectorClient().call(). No `directory`/workspaceForDirectory resolution here -- unlike
  * every other tool in this extension, this one doesn't target an existing local directory, it
  * creates a new registered workspace from a fetched external repo.
  */
 export interface RepoFetchOperations {
-	fetch(host: string, owner: string, repo: string, ref: string | null, forceRefresh?: boolean): Promise<RepoFetchResult & { workspaceId: string }>;
+	fetch(
+		host: string,
+		owner: string,
+		repo: string,
+		ref: string | null,
+		forceRefresh: boolean | undefined,
+		call: LectorVehicleCall,
+	): Promise<RepoFetchResult & { workspaceId: string }>;
 }
 
 export function createLectorRepoFetchOperations(): RepoFetchOperations {
 	return {
-		async fetch(host, owner, repo, ref, forceRefresh) {
-			const client = await lectorClient();
-			return client.callOnce("repo.fetch", { host, owner, repo, ref, forceRefresh });
+		fetch(host, owner, repo, ref, forceRefresh, call) {
+			return invokeLectorVehicleOperation<RepoFetchResult & { workspaceId: string }>(
+				"repo.fetch",
+				{ host, owner, repo, ref, forceRefresh },
+				REPO_WRITE_PERMISSIONS,
+				call,
+			);
 		},
 	};
 }

package/extension/src/symbol-annotation/operations.ts

@@ -1,5 +1,10 @@
 import type { OperationInputs, OperationOutputs } from "@danypops/lector";
-import { lectorClient, withWorkspace, workspaceForAnnotationPath } from "../lector-client.ts";
+import { withWorkspace, workspaceForAnnotationPath } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
+
+/** Match ANNOTATION_READ_PERMISSIONS/ANNOTATION_WRITE_PERMISSIONS' own declared values server-side (symbol-annotation/operation-registration.ts). */
+const ANNOTATION_READ_PERMISSIONS = ["workspace:read"];
+const ANNOTATION_WRITE_PERMISSIONS = ["workspace:write"];
 
 /** 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 {
@@ -23,11 +28,13 @@ export interface SymbolAnnotationOperations {
 		title: string,
 		body: string,
 		anchors: readonly AnnotationAnchorInput[],
+		call: LectorVehicleCall,
 	): Promise<OperationOutputs["workspace.createAnnotation"]>;
-	get(path: string, id: string): Promise<OperationOutputs["workspace.getAnnotation"]>;
+	get(path: string, id: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.getAnnotation"]>;
 	list(
 		path: string,
-		options?: { subtype?: string; status?: OperationInputs["workspace.listAnnotations"]["status"]; maxResults?: number; query?: string },
+		options: { subtype?: string; status?: OperationInputs["workspace.listAnnotations"]["status"]; maxResults?: number; query?: string },
+		call: LectorVehicleCall,
 	): Promise<OperationOutputs["workspace.listAnnotations"]>;
 	refresh(
 		path: string,
@@ -36,101 +43,123 @@ export interface SymbolAnnotationOperations {
 		title: string,
 		body: string,
 		anchors: readonly AnnotationAnchorInput[],
+		call: LectorVehicleCall,
 	): Promise<OperationOutputs["workspace.refreshAnnotation"]>;
-	scrub(path: string, id: string): Promise<OperationOutputs["workspace.scrubAnnotation"]>;
-	restore(path: string, id: string): Promise<OperationOutputs["workspace.restoreAnnotation"]>;
-	contain(path: string, parentId: string, childId: string): Promise<OperationOutputs["workspace.containAnnotation"]>;
-	uncontain(path: string, parentId: string, childId: string): Promise<OperationOutputs["workspace.uncontainAnnotation"]>;
-	tree(path: string, rootId: string, maxDepth: number): Promise<OperationOutputs["workspace.annotationTree"]>;
+	scrub(path: string, id: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.scrubAnnotation"]>;
+	restore(path: string, id: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.restoreAnnotation"]>;
+	contain(path: string, parentId: string, childId: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.containAnnotation"]>;
+	uncontain(path: string, parentId: string, childId: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.uncontainAnnotation"]>;
+	tree(path: string, rootId: string, maxDepth: number, call: LectorVehicleCall): Promise<OperationOutputs["workspace.annotationTree"]>;
 }
 
 export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperations {
 	return {
-		async create(path, subtype, title, body, anchors) {
+		async create(path, subtype, title, body, anchors, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.createAnnotation", { workspaceId, subtype, title, body, anchors });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.createAnnotation"]>(
+						"workspace.createAnnotation",
+						{ workspaceId, subtype, title, body, anchors },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async get(path, id) {
+		async get(path, id, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.call("workspace.getAnnotation", { workspaceId, id });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.getAnnotation"]>(
+						"workspace.getAnnotation",
+						{ workspaceId, id },
+						ANNOTATION_READ_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async list(path, options = {}) {
+		async list(path, options, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.call("workspace.listAnnotations", {
-						workspaceId,
-						subtype: options.subtype,
-						status: options.status,
-						maxResults: options.maxResults,
-						query: options.query,
-					});
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.listAnnotations"]>(
+						"workspace.listAnnotations",
+						{ workspaceId, subtype: options.subtype, status: options.status, maxResults: options.maxResults, query: options.query },
+						ANNOTATION_READ_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async refresh(path, id, subtype, title, body, anchors) {
+		async refresh(path, id, subtype, title, body, anchors, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.refreshAnnotation", { workspaceId, id, subtype, title, body, anchors });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.refreshAnnotation"]>(
+						"workspace.refreshAnnotation",
+						{ workspaceId, id, subtype, title, body, anchors },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async scrub(path, id) {
+		async scrub(path, id, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.scrubAnnotation", { workspaceId, id });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.scrubAnnotation"]>(
+						"workspace.scrubAnnotation",
+						{ workspaceId, id },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async restore(path, id) {
+		async restore(path, id, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.restoreAnnotation", { workspaceId, id });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.restoreAnnotation"]>(
+						"workspace.restoreAnnotation",
+						{ workspaceId, id },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async contain(path, parentId, childId) {
+		async contain(path, parentId, childId, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.containAnnotation", { workspaceId, parentId, childId });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.containAnnotation"]>(
+						"workspace.containAnnotation",
+						{ workspaceId, parentId, childId },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async uncontain(path, parentId, childId) {
+		async uncontain(path, parentId, childId, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.callOnce("workspace.uncontainAnnotation", { workspaceId, parentId, childId });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.uncontainAnnotation"]>(
+						"workspace.uncontainAnnotation",
+						{ workspaceId, parentId, childId },
+						ANNOTATION_WRITE_PERMISSIONS,
+						call,
+					),
 			);
 		},
-		async tree(path, rootId, maxDepth) {
+		async tree(path, rootId, maxDepth, call) {
 			return withWorkspace(
 				() => workspaceForAnnotationPath(path),
-				async ({ workspaceId }) => {
-					const client = await lectorClient();
-					return client.call("workspace.annotationTree", { workspaceId, rootId, maxDepth });
-				},
+				({ workspaceId }) =>
+					invokeLectorVehicleOperation<OperationOutputs["workspace.annotationTree"]>(
+						"workspace.annotationTree",
+						{ workspaceId, rootId, maxDepth },
+						ANNOTATION_READ_PERMISSIONS,
+						call,
+					),
 			);
 		},
 	};

package/extension/src/vehicle-client.ts

@@ -0,0 +1,124 @@
+/**
+ * A real VehicleClient bridge to the Lector daemon's /vehicle/* HTTP surface (see Lector's own
+ * daemon.ts, which mounts @danypops/vehicle-server/http's createVehicleHttpApp additively
+ * alongside the legacy /api/v1/ops endpoint). Used by whichever pi-lector tool actions have
+ * migrated onto Vehicle's operation-descriptor style so far (git status/log/diff today -- see
+ * git/operations.ts) -- distinct from lector-client.ts's own LectorClient/OperationName
+ * dispatch, which every other tool action still uses and will keep using until its own backing
+ * operation migrates too.
+ *
+ * Same pattern already proven for web-spider's web_category (pi-web-spider's
+ * invokeWebSpiderVehicleOperation) -- see also @danypops/vehicle-client-pi's own
+ * invokeVehicleOperation() doc comment: a consumer whose tool deliberately consolidates several
+ * operations behind one action parameter (Anthropic's own tool-design guidance) gets the same
+ * cross-cutting policy layer (activity broadcasting, the local /safety ask gate, the server
+ * approval-required retry dance, idempotency-key/correlationId derivation) a
+ * registerVehicleTools()-registered tool gets automatically, without regressing its own
+ * consolidated shape into one Pi tool per operation.
+ *
+ * Deliberately does NOT auto-spawn the daemon, matching lector-client.ts's own stated
+ * convention: a clear "start it with `lector serve`" error beats guessing at a lifecycle the
+ * user didn't ask for.
+ */
+import { resolveLectorDaemonConnection } from "@danypops/lector";
+import { createReconnectingVehicleClient, daemonInstanceIdentity } from "@danypops/vehicle-client/daemon-client";
+import { RemoteVehicleClient } from "@danypops/vehicle-client/http";
+import { invokeVehicleOperation } from "@danypops/vehicle-client-pi";
+import type { VehicleClient } from "@danypops/vehicle-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type VehicleClientConnector = () => Promise<VehicleClient>;
+
+function connectLectorVehicleClient(): Promise<VehicleClient> {
+	const { host, port, token } = resolveLectorDaemonConnection();
+	return Promise.resolve(new RemoteVehicleClient({ baseUrl: `http://${host}:${port}`, token }));
+}
+
+function resolveLectorVehicleIdentity() {
+	try {
+		const { host, port } = resolveLectorDaemonConnection();
+		return daemonInstanceIdentity(`http://${host}:${port}`);
+	} catch {
+		return daemonInstanceIdentity("unresolved");
+	}
+}
+
+let connector: VehicleClientConnector = connectLectorVehicleClient;
+let vehicleClient: VehicleClient = createReconnectingVehicleClient(() => connector(), {
+	resolveIdentity: resolveLectorVehicleIdentity,
+	// connectRetry:true (vehicle-client's own bounded background retry budget) covers a daemon
+	// that crashed and is mid systemd-restart -- without it, the very first call during that
+	// window fails immediately instead of waiting the restart out, same policy as
+	// lector-client.ts's own createRetryingLectorClient.
+	connectRetry: true,
+});
+
+export function setLectorVehicleClientConnectorForTests(value: VehicleClientConnector): void {
+	connector = value;
+	vehicleClient = createReconnectingVehicleClient(() => connector());
+}
+
+export function resetLectorVehicleClientForTests(): void {
+	connector = connectLectorVehicleClient;
+	vehicleClient = createReconnectingVehicleClient(() => connector(), { resolveIdentity: resolveLectorVehicleIdentity, connectRetry: true });
+}
+
+/**
+ * Everything about a real Pi tool call needed to invoke a Vehicle operation through it, except
+ * which permissions this call declares -- that's operation-specific (matches whichever
+ * *_PERMISSIONS constant the backing operation's own registration declared server-side), so it's
+ * a separate invokeLectorVehicleOperation() argument, not part of this reusable per-tool-call
+ * envelope.
+ *
+ * Deliberately has no `onUpdate` field: invokeVehicleOperation()'s own progress callback is typed
+ * against PiVehicleToolDetails (vehicle-client-pi's generic {vehicle, progress}/{vehicle,
+ * presentation} shape), never a specific tool's own XToolDetails -- none of git/
+ * symbol_annotations/repo_cache/external_search/mutation_history's operations are long-running
+ * enough to emit real mid-flight progress in practice, and forwarding a caller's own
+ * differently-shaped onUpdate here would need an unsafe cast to paper over a real type mismatch,
+ * not just a lint complaint.
+ */
+export interface LectorVehicleCall {
+	readonly toolName: string;
+	readonly toolCallId: string;
+	readonly signal?: AbortSignal;
+	readonly context: ExtensionContext;
+}
+
+/**
+ * Dispatches one already-VehicleRegistry-backed Lector operation through vehicle-client-pi's
+ * cross-cutting policy layer instead of a bare lectorClient().call(), which would forfeit all of
+ * it. Fetches the manifest on every call rather than caching it: these are low-frequency,
+ * user-driven tool actions (not a hot loop), and a fresh manifest fetch is one cheap extra round
+ * trip that also self-heals if the daemon's own operation set ever changes between calls.
+ *
+ * Generic over T (the caller's own known output shape for this specific operation) so every call
+ * site gets a properly typed result without its own unsafe cast -- the one unavoidable narrowing
+ * (result.details.output is typed unknown; see PiVehicleToolDetails) happens exactly once, here,
+ * trusted because the caller already knows which operation it invoked and what shape that
+ * operation's own registered output schema produces -- same trust boundary Lector's own
+ * dispatch-through-registry.ts documents for its identical generic-unwrap seam.
+ */
+export async function invokeLectorVehicleOperation<T>(
+	operationName: string,
+	input: Record<string, unknown>,
+	permissions: readonly string[],
+	call: LectorVehicleCall,
+): Promise<T> {
+	const manifest = await vehicleClient.manifest();
+	const descriptor = manifest.operations.find((op) => op.name === operationName);
+	if (!descriptor) throw new Error(`Lector Vehicle manifest has no operation named '${operationName}'`);
+	const result = await invokeVehicleOperation({
+		client: vehicleClient,
+		manifest,
+		descriptor,
+		toolName: call.toolName,
+		toolCallId: call.toolCallId,
+		input,
+		context: call.context,
+		signal: call.signal,
+		options: { permissions },
+	});
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see this function's own doc comment.
+	return result.details.output as T;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.12.9",
+	"version": "0.12.11",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -18,15 +18,18 @@
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*",
-		"typebox": "*"
+		"typebox": "*",
+		"@danypops/vehicle-client-pi": "^0.42.1"
 	},
 	"dependencies": {
-		"@danypops/vehicle-client": "^0.8.2",
-		"@danypops/lector": "^0.18.0",
+		"@danypops/vehicle-client": "^0.10.1",
+		"@danypops/vehicle-core": "^0.17.1",
+		"@danypops/lector": "^0.19.3",
 		"malevich-tui-components": "^0.25.0",
 		"picomatch": "^4.0.5"
 	},
 	"devDependencies": {
+		"@danypops/vehicle-client-pi": "^0.42.1",
 		"@danypops/pi-extension-harness": "^0.2.0",
 		"@danypops/pi-tui-harness": "^0.0.1",
 		"@earendil-works/pi-ai": "^0.81.1",