@danypops/pi-lector 0.12.6 → 0.12.8

package/extension/src/client-diagnostics.ts

@@ -0,0 +1,46 @@
+import type { RetryingClientDiagnosticEvent } from "@danypops/vehicle-client/daemon-client";
+
+/**
+ * Formats one createRetryingClient diagnostic event as a single, compact line -- the same real
+ * RCA gap @danypops/vehicle-client's own onEvent hook was added to close: a scrubbed "connector
+ * unavailable" error at the tool-call boundary otherwise gives no way to tell, after the fact,
+ * whether it was a genuine fresh connect() failure, a circuit-breaker short-circuit (no connect
+ * attempted at all), or an in-flight operation's stale-connection retry. Never includes a stack
+ * trace -- name and message only, matching this house's other client-diagnostic channels
+ * (@danypops/vehicle-client-pi's own client-diagnostics.ts).
+ */
+/** Never risks Object's default `[object Object]` stringification for a non-Error, non-string throw. */
+function describeError(error: unknown): { name: string; message: string } {
+	if (error instanceof Error) return { name: error.name, message: error.message };
+	if (typeof error === "string") return { name: "string", message: error };
+	if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return { name: typeof error, message: String(error) };
+	return { name: typeof error, message: "(unprintable value)" };
+}
+
+export function formatClientDiagnosticEvent(event: RetryingClientDiagnosticEvent): string {
+	const parts = [`[lector-client] ${event.type}`];
+	if (event.attempt !== undefined) parts.push(`attempt=${event.attempt}`);
+	if (event.consecutiveFailures !== undefined) parts.push(`consecutiveFailures=${event.consecutiveFailures}`);
+	if (event.operationId !== undefined) parts.push(`operationId=${event.operationId}`);
+	if (event.error !== undefined) {
+		const { name, message } = describeError(event.error);
+		parts.push(`error=${name}: ${message}`);
+	}
+	return parts.join(" ");
+}
+
+/**
+ * Logs a createRetryingClient diagnostic event to stderr, only when LECTOR_CLIENT_DIAG is set --
+ * zero cost and zero output for every session that never opts in, matching the env-gated
+ * convention @danypops/vehicle-client-pi's own VEHICLE_CLIENT_DIAG already established in this
+ * house. Never throws: onEvent's own contract requires it stay side-effect-light, and a broken
+ * local console (or a formatting bug) must not take down a real client call.
+ */
+export function logClientDiagnosticEvent(event: RetryingClientDiagnosticEvent): void {
+	if (!process.env.LECTOR_CLIENT_DIAG) return;
+	try {
+		console.error(formatClientDiagnosticEvent(event));
+	} catch {
+		// best-effort only -- see doc comment above.
+	}
+}

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

@@ -7,7 +7,7 @@ export type EditorAction = { kind: "save" } | { kind: "save-and-quit" } | { kind
 const BACKSPACE_KEYS = new Set(["\x7f", "\b"]);
 
 /**
- * Pure neovim-style modal editing state machine: mode transitions, cursor motion, and buffer
+ * Pure 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

package/extension/src/editor/index.ts

@@ -0,0 +1,22 @@
+/**
+ * The real, host-agnostic editor surface -- deliberately its own subpath export
+ * (`@danypops/pi-lector/editor`), not part of this package's own Pi extension entry point
+ * (`extension/src/index.ts`, which is loaded only via Pi's own extension-discovery mechanism and
+ * has no package export of its own).
+ *
+ * Everything re-exported here has zero structural dependency on Pi's extension machinery --
+ * confirmed directly: ModalEditorComponent's own constructor only ever calls
+ * `tui.requestRender()`/`tui.terminal.rows` and `theme.fg()`/`theme.bg()` (EditorTheme is its own
+ * interface, deliberately narrowed away from pi-coding-agent's full Theme shape), and
+ * ModalEditorHost is a plain `{filePath, save, hover}` port with no Pi types anywhere in it.
+ * EditorState's own only dependency is `@danypops/lector`'s LiveBuffer -- no I/O, no rendering.
+ *
+ * This lets any real host (not just a Pi session that has loaded this package as an extension)
+ * 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).
+ */
+
+export { type EditorAction, type EditorMode, EditorState } from "./editor-state.ts";
+export type { EditorTheme } from "./editor-theme.ts";
+export { ModalEditorComponent, type ModalEditorHost } from "./modal-editor-component.ts";

package/extension/src/editor/{neovim-editor-component.ts → modal-editor-component.ts}

@@ -10,7 +10,7 @@ import type { EditorTheme } from "./editor-theme.ts";
 
 export type { EditorTheme } from "./editor-theme.ts";
 
-export interface NeovimEditorHost {
+export interface ModalEditorHost {
 	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>;
@@ -28,16 +28,16 @@ const CAPTURE_COLOR: Record<string, ThemeColor> = {
 };
 
 /**
- * A real, full-file, neovim-style modal code editor Component -- not a CustomEditor subclass
+ * A real, full-file, 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 {
+export class ModalEditorComponent implements Component {
 	private readonly state: EditorState;
-	private readonly host: NeovimEditorHost;
+	private readonly host: ModalEditorHost;
 	private readonly tui: TUI;
 	private readonly theme: EditorTheme;
 	private readonly done: () => void;
@@ -47,7 +47,7 @@ export class NeovimEditorComponent implements Component {
 	private statusMessage = "";
 	private highlightCache: { text: string; spans: readonly HighlightSpan[] } | undefined;
 
-	constructor(tui: TUI, theme: EditorTheme, host: NeovimEditorHost, content: string, done: () => void) {
+	constructor(tui: TUI, theme: EditorTheme, host: ModalEditorHost, content: string, done: () => void) {
 		this.tui = tui;
 		this.theme = theme;
 		this.host = host;

package/extension/src/index.ts

@@ -1,3 +1,5 @@
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type {
 	CachedRepositoryPage,
@@ -44,7 +46,7 @@ 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 { isFilesystemRoot } from "@danypops/lector";
+import { classifyAutoPopulationRoot, isFilesystemRoot } from "@danypops/lector";
 import { createLectorApplyPatchOperations } from "./apply-patch/operations.ts";
 import { formatApplyPatchCall, formatApplyPatchResult } from "./apply-patch/rendering.ts";
 import { createLectorCodeIntelligenceOperations } from "./code-intelligence/operations.ts";
@@ -75,7 +77,7 @@ import { createLectorEditOperations } from "./edit/operations.ts";
 import { openDirectoryExplorer } from "./editor/directory-explorer-operations.ts";
 import { ExplorerComponent, type ExplorerResult } from "./editor/explorer-component.ts";
 import { runExplorerFlow } from "./editor/explorer-flow.ts";
-import { NeovimEditorComponent, type NeovimEditorHost } from "./editor/neovim-editor-component.ts";
+import { ModalEditorComponent, type ModalEditorHost } from "./editor/modal-editor-component.ts";
 import { openEditorFile } from "./editor/operations.ts";
 import { createExternalSearchOperations } from "./external-search/operations.ts";
 import {
@@ -214,10 +216,23 @@ export default function (pi: ExtensionAPI) {
 	 * intentional fallback for a raw read/write of a file outside any git repo can register
 	 * exactly this as a "new workspace", and auto-populating it would attempt a full
 	 * filesystem-wide symbol-graph scan -- confirmed live as a real, previously-shipped bug.
+	 *
+	 * Also short-circuits a broad host directory (home directory, an XDG config/cache/data
+	 * root, a dotfile directory) the exact same way workspace.populateSymbolGraph's own
+	 * server-side gate would refuse it -- avoids the round trip (and the queue-behind-real-
+	 * projects ergonomics this caused live for ~/.pi/agent) entirely, using the identical
+	 * classification Lector itself uses so the two never drift. A readdir failure (permission,
+	 * race) is treated as "can't tell, don't block" -- the server-side gate is still authoritative.
 	 */
 	function startMonitoringRoot(root: string, ctx: Parameters<Parameters<ExtensionAPI["on"]>[1]>[1]): void {
 		if (isFilesystemRoot(root)) return;
 		if (monitoringRoots.has(root)) return;
+		try {
+			const topLevelEntries = readdirSync(root);
+			if (classifyAutoPopulationRoot({ rootPath: root, homeDir: homedir(), topLevelEntries }) === "broad-non-project") return;
+		} catch {
+			// Can't read it here -- let the server-side gate be the authoritative answer.
+		}
 		monitoringRoots.add(root);
 		const thisGeneration = sessionGeneration;
 		void monitorWorkspaceCache(cacheOperations, {
@@ -372,7 +387,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			await commandCtx.ui.custom<void>((tui, theme, _keybindings, done) => {
-				const host: NeovimEditorHost = {
+				const host: ModalEditorHost = {
 					filePath: absolutePath,
 					save: (text) => session.save(text),
 					hover: async (line, character) => {
@@ -380,7 +395,7 @@ export default function (pi: ExtensionAPI) {
 						return result.hover;
 					},
 				};
-				return new NeovimEditorComponent(tui, theme, host, session.content, () => done(undefined));
+				return new ModalEditorComponent(tui, theme, host, session.content, () => done(undefined));
 			}, editorOverlayOptions);
 		}
 
@@ -405,7 +420,7 @@ export default function (pi: ExtensionAPI) {
 		}
 
 		pi.registerCommand("editor", {
-			description: "Open a file in a neovim-style modal code editor, or a filesystem explorer with no path",
+			description: "Open a file in a modal code editor, or a filesystem explorer with no path",
 			handler: async (args, commandCtx) => {
 				const target = args.trim();
 				if (!target) {
@@ -1126,7 +1141,7 @@ export default function (pi: ExtensionAPI) {
 			name: "workspace_cache",
 			label: "Workspace Cache",
 			description:
-				"Checks or drives population of the workspace's persisted symbol graph -- the store reachable_from, symbol_annotations (anchor resolution), reference_based_rename, and workspace_map all read from, separate from the live language-server index find_symbols/hover/go_to_definition use. action=status reports not-cached/caching/partial/cached for the given bounds, without starting work. action=populate requests a scan and briefly waits for fast completion. action=wait subscribes to daemon job completion, with bounded status polling only when push delivery is unavailable. action=job_status is a point-in-time diagnostic read.",
+				"Checks or drives population of the workspace's persisted symbol graph -- the store reachable_from, symbol_annotations (anchor resolution), reference_based_rename, and workspace_map all read from, separate from the live language-server index find_symbols/hover/go_to_definition use. action=status reports not-cached/caching/partial/cached for the given bounds, without starting work. action=populate requests a scan and briefly waits for fast completion; a source file changing mid-scan (e.g. a concurrent edit or rename) is retried automatically in the background for up to a minute before surfacing as a real failure, no manual re-run needed. action=wait subscribes to daemon job completion, with bounded status polling only when push delivery is unavailable. action=job_status is a point-in-time diagnostic read.",
 			promptSnippet: "Check or force-populate the workspace's persisted symbol graph",
 			promptGuidelines: [
 				"Use action=populate with a larger maxFiles/maxSymbolsPerFile before relying on reachable_from/symbol_annotations/reference_based_rename against a workspace bigger than the default 500-file auto-scan -- their own errors (empty results, UnknownAnnotationAnchor, ReferenceBasedRenameRequiresFreshGraph) usually mean the graph never reached the files you need, not that population is simply still catching up.",

package/extension/src/lector-client.ts

@@ -11,6 +11,7 @@ import {
 	type WorkspaceResolutionRequest,
 } from "@danypops/lector";
 import { createRetryingClient, isLikelyStaleConnectionError, type RetryingClient } from "@danypops/vehicle-client/daemon-client";
+import { logClientDiagnosticEvent } from "./client-diagnostics.ts";
 
 /**
  * Lazily connects to a running Lector daemon and caches, per resolution request, the
@@ -44,6 +45,9 @@ let connector: ClientConnector = () => connectLectorClient();
 const retryingClient: RetryingClient<LectorClient> = createRetryingClient(() => connector(), {
 	label: "Lector",
 	isStaleConnectionError: (error) => error instanceof LectorDaemonUnavailable || isLikelyStaleConnectionError(error),
+	// Purely observational, opt-in via LECTOR_CLIENT_DIAG -- see client-diagnostics.ts's own doc
+	// comment for the exact RCA gap this closes.
+	onEvent: logClientDiagnosticEvent,
 });
 
 /**
@@ -220,6 +224,38 @@ export function workspaceForPathOrDirectory(path: string): Promise<ResolvedWorks
 	return resolveWorkspace({ strategy: "path-or-directory", path });
 }
 
+/** Raised by workspaceForAnnotationPath for a path that does not exist on disk at all -- a distinct, explicit failure the caller must handle, never silently guessed as "must be a file, take its dirname()." */
+export class AnnotationPathDoesNotExist extends Error {
+	constructor(readonly path: string) {
+		super(`"${path}" does not exist -- a symbol-annotation scope must be a real project directory or an existing source file`);
+		this.name = "AnnotationPathDoesNotExist";
+	}
+}
+
+/**
+ * For symbol-annotation's own `path` parameter, which genuinely means "which workspace does this
+ * belong to" and can honestly be either an existing project directory or one specific source
+ * file -- unlike workspaceForCodeIntelligencePath (files only, dirname() unconditional), a real
+ * project directory resolves via its own language markers, not its parent's. A genuinely
+ * nonexistent path throws AnnotationPathDoesNotExist rather than being silently treated as a file.
+ */
+export async function workspaceForAnnotationPath(path: string): Promise<ResolvedWorkspace> {
+	const request: WorkspaceResolutionRequest = { strategy: "code-intelligence-path-or-directory", path };
+	const key = requestCacheKey(request);
+	const cached = resolutionCache.get(key);
+	if (cached) return cached;
+	const client = await lectorClient();
+	const outcome = await client.callOnce("workspace.resolvePath", request);
+	if (!outcome.found) {
+		if (outcome.reason === "nonexistent-path") throw new AnnotationPathDoesNotExist(path);
+		throw new Error(`workspace.resolvePath unexpectedly reported not-found for code-intelligence-path-or-directory: ${path}`);
+	}
+	const resolved: ResolvedWorkspace = { workspaceId: outcome.workspaceId, root: outcome.root };
+	resolutionCache.set(key, resolved);
+	if (outcome.created) onNewWorkspace?.(outcome.root);
+	return resolved;
+}
+
 /**
  * The nearest ancestor of an already-resolved project root whose own package.json declares that
  * project as a workspace member via npm/yarn/bun's "workspaces" field -- undefined (no

package/extension/src/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, workspaceForAnnotationPath } 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 {
@@ -9,10 +9,12 @@ export interface AnnotationAnchorInput {
 }
 
 /**
- * Thin wrappers over Lector's annotation operations. Anchored to a workspace
- * via the first anchor's own path (workspaceForCodeIntelligencePath) --
- * every operation that needs a workspace already has at least one real
- * anchor position or an id whose workspace the caller already knows.
+ * Thin wrappers over Lector's annotation operations. Every operation resolves its workspace from
+ * its own `path` parameter via workspaceForAnnotationPath -- a real project directory or an
+ * existing source file, never dirname()'d unconditionally the way a plain code-intelligence
+ * path is. `path` here means "which workspace this call belongs to," not necessarily one of the
+ * operation's own anchors (create/refresh's anchors carry their own, separately-validated paths
+ * server-side).
  */
 export interface SymbolAnnotationOperations {
 	create(
@@ -46,7 +48,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 	return {
 		async create(path, subtype, title, body, anchors) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.createAnnotation", { workspaceId, subtype, title, body, anchors });
@@ -55,7 +57,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async get(path, id) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.call("workspace.getAnnotation", { workspaceId, id });
@@ -64,7 +66,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async list(path, options = {}) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.call("workspace.listAnnotations", {
@@ -79,7 +81,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async refresh(path, id, subtype, title, body, anchors) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.refreshAnnotation", { workspaceId, id, subtype, title, body, anchors });
@@ -88,7 +90,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async scrub(path, id) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.scrubAnnotation", { workspaceId, id });
@@ -97,7 +99,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async restore(path, id) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.restoreAnnotation", { workspaceId, id });
@@ -106,7 +108,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async contain(path, parentId, childId) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.containAnnotation", { workspaceId, parentId, childId });
@@ -115,7 +117,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async uncontain(path, parentId, childId) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.callOnce("workspace.uncontainAnnotation", { workspaceId, parentId, childId });
@@ -124,7 +126,7 @@ export function createLectorSymbolAnnotationOperations(): SymbolAnnotationOperat
 		},
 		async tree(path, rootId, maxDepth) {
 			return withWorkspace(
-				() => workspaceForCodeIntelligencePath(path),
+				() => workspaceForAnnotationPath(path),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					return client.call("workspace.annotationTree", { workspaceId, rootId, maxDepth });

package/extension/src/workspace-cache/operations.ts

@@ -15,9 +15,26 @@ export interface JobWatchHandle {
 
 export type JobWatchOutcome = { readonly status: "subscribed"; readonly handle: JobWatchHandle } | { readonly status: "unavailable" };
 
+/**
+ * The daemon's own default (0/omitted -- fail fast on a WorkspaceChangedDuringPopulation race)
+ * would surface a live-editing/rename race straight to this tool's own caller as an opaque
+ * error. This tool's whole point is "make this converge for me" -- a bounded background retry
+ * costs the caller nothing extra (it runs inside the job the caller is already waiting on or
+ * polling, not as additional synchronous tool-call latency), so it defaults on here specifically,
+ * unlike the raw daemon operation which stays fail-fast by default for programmatic callers that
+ * want today's exact contract.
+ */
+const DEFAULT_POPULATE_RETRY_TIME_BUDGET_MS = 60_000;
+
 export interface WorkspaceCacheOperations {
 	status(directory: string, maxFiles: number, maxSymbolsPerFile: number): Promise<WorkspaceCacheStatus>;
-	submit(directory: string, maxFiles: number, maxSymbolsPerFile: number, waitMs?: number): Promise<JobSnapshot<PopulateSymbolGraphResult>>;
+	submit(
+		directory: string,
+		maxFiles: number,
+		maxSymbolsPerFile: number,
+		waitMs?: number,
+		retryTimeBudgetMs?: number,
+	): Promise<JobSnapshot<PopulateSymbolGraphResult>>;
 	jobStatus(jobId: string): Promise<JobSnapshot<PopulateSymbolGraphResult>>;
 	watchJob?(jobId: string, onJob: (job: JobSnapshot<PopulateSymbolGraphResult>) => void): Promise<JobWatchOutcome>;
 }
@@ -33,14 +50,14 @@ export function createWorkspaceCacheOperations(): WorkspaceCacheOperations {
 				},
 			);
 		},
-		submit(directory, maxFiles, maxSymbolsPerFile, waitMs = 0) {
+		submit(directory, maxFiles, maxSymbolsPerFile, waitMs = 0, retryTimeBudgetMs = DEFAULT_POPULATE_RETRY_TIME_BUDGET_MS) {
 			return withWorkspace(
 				() => workspaceForProjectDirectory(directory),
 				async ({ workspaceId }) => {
 					const client = await lectorClient();
 					const { job } = await client.callOnce("job.submit", {
 						operation: "workspace.populateSymbolGraph",
-						input: { workspaceId, maxFiles, maxSymbolsPerFile },
+						input: { workspaceId, maxFiles, maxSymbolsPerFile, retryTimeBudgetMs },
 						waitMs,
 					});
 					return job;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.12.6",
+	"version": "0.12.8",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -12,15 +12,18 @@
 	"pi": {
 		"extensions": ["extension/src/index.ts"]
 	},
+	"exports": {
+		"./editor": "./extension/src/editor/index.ts"
+	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	},
 	"dependencies": {
-		"@danypops/vehicle-client": "^0.2.0",
+		"@danypops/vehicle-client": "^0.8.2",
 		"@danypops/lector": "^0.18.0",
-		"malevich-tui-components": "^0.19.0",
+		"malevich-tui-components": "^0.25.0",
 		"picomatch": "^4.0.5"
 	},
 	"devDependencies": {