@danypops/pi-lector 0.13.11 → 0.15.0

package/extension/src/presentation/presentation-contract.ts

@@ -0,0 +1,148 @@
+import type { JsonValue } from "@danypops/vehicle-core";
+import type { AgentToolResult, AgentToolUpdateCallback, Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { TSchema } from "typebox";
+import { boundModelContentText, DEFAULT_MODEL_CONTENT_BYTES } from "./model-content.ts";
+import { type PresentationFamily, presentationFamily } from "./tool-presentation.ts";
+
+export const LECTOR_PRESENTATION_SCHEMA = "pi-lector.presentation/v1";
+export const DEFAULT_LECTOR_PRESENTATION_MAX_BYTES = 128 * 1024;
+
+interface LectorPresentationBase {
+	readonly schema: typeof LECTOR_PRESENTATION_SCHEMA;
+	readonly tool: string;
+	readonly action: string | null;
+	readonly payload: JsonValue;
+}
+
+/** Versioned presentation variants persisted independently from model-facing content. */
+export type LectorToolPresentation = {
+	readonly [Family in PresentationFamily]: LectorPresentationBase & { readonly family: Family };
+}[PresentationFamily];
+
+export type LectorPresentationEnvelope = LectorToolPresentation;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isJsonValue(value: unknown): value is JsonValue {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	if (isRecord(value)) return Object.values(value).every(isJsonValue);
+	return false;
+}
+
+function serializedJsonValue(value: unknown): JsonValue {
+	if (value === undefined) return null;
+	let serialized: string;
+	try {
+		serialized = JSON.stringify(value, (_key, candidate: unknown) => {
+			if (typeof candidate === "number" && !Number.isFinite(candidate)) throw new TypeError("non-finite number");
+			if (typeof candidate === "bigint" || typeof candidate === "function" || typeof candidate === "symbol") {
+				throw new TypeError(`unsupported ${typeof candidate}`);
+			}
+			return candidate;
+		});
+	} catch (error) {
+		throw new TypeError(`presentation details must be JSON serializable: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const parsed: unknown = JSON.parse(serialized);
+	if (!isJsonValue(parsed)) throw new TypeError("presentation details must contain only JSON values");
+	return parsed;
+}
+
+/** Projects one tool's renderer details into the versioned, serializable session boundary. */
+export function projectLectorPresentation(
+	tool: string,
+	details: unknown,
+	maxBytes = DEFAULT_LECTOR_PRESENTATION_MAX_BYTES,
+	actionOverride?: string,
+): LectorPresentationEnvelope {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new TypeError("presentation maxBytes must be a positive integer");
+	const action = actionOverride ?? (isRecord(details) && typeof details.action === "string" ? details.action : null);
+	const envelope: LectorPresentationEnvelope = {
+		schema: LECTOR_PRESENTATION_SCHEMA,
+		tool,
+		action,
+		family: presentationFamily(tool, action ?? undefined),
+		payload: serializedJsonValue(details),
+	};
+	const bytes = Buffer.byteLength(JSON.stringify(envelope), "utf8");
+	if (bytes > maxBytes) throw new RangeError(`presentation details exceed ${maxBytes} bytes (${bytes} observed)`);
+	return envelope;
+}
+
+/** Validates the shared envelope. Domain renderers retain responsibility for validating their payload variant. */
+export function parseLectorPresentation(details: unknown, expectedTool: string): JsonValue | undefined {
+	if (!isRecord(details)) return undefined;
+	if (details.schema !== LECTOR_PRESENTATION_SCHEMA || details.tool !== expectedTool || !("payload" in details)) return undefined;
+	if (details.action !== null && typeof details.action !== "string") return undefined;
+	if (details.family !== presentationFamily(expectedTool, typeof details.action === "string" ? details.action : undefined)) return undefined;
+	try {
+		return serializedJsonValue(details.payload);
+	} catch {
+		return undefined;
+	}
+}
+
+function fallbackText(result: AgentToolResult<unknown>, theme: Theme): Text {
+	const content = result.content
+		.filter((block): block is Extract<(typeof result.content)[number], { type: "text" }> => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+	return new Text(theme.fg("toolOutput", content || "No result."), 0, 0);
+}
+
+export interface LectorPresentationOptions {
+	readonly maxBytes?: number;
+	readonly maxModelContentBytes?: number;
+}
+
+/** Wraps a production tool so persisted renderer details cross one validated, bounded envelope. */
+export function withLectorPresentation<TParams extends TSchema, TDetails, TState>(
+	tool: ToolDefinition<TParams, TDetails, TState>,
+	options: LectorPresentationOptions = {},
+): ToolDefinition<TParams, LectorPresentationEnvelope, TState> {
+	const maxBytes = options.maxBytes ?? DEFAULT_LECTOR_PRESENTATION_MAX_BYTES;
+	const maxModelContentBytes = options.maxModelContentBytes ?? DEFAULT_MODEL_CONTENT_BYTES;
+	return {
+		...tool,
+		async execute(toolCallId, params, signal, onUpdate, context) {
+			const parameterRecord = params as Record<string, unknown>;
+			const action =
+				typeof parameterRecord.action === "string"
+					? parameterRecord.action
+					: typeof parameterRecord.direction === "string"
+						? parameterRecord.direction
+						: undefined;
+			const boundedContent = (content: AgentToolResult<unknown>["content"]): AgentToolResult<unknown>["content"] =>
+				content.map((block) => (block.type === "text" ? { ...block, text: boundModelContentText(block.text, maxModelContentBytes) } : block));
+			const wrappedUpdate: AgentToolUpdateCallback<TDetails> | undefined = onUpdate
+				? (update) =>
+						onUpdate({
+							...update,
+							content: boundedContent(update.content),
+							details: projectLectorPresentation(tool.name, update.details, maxBytes, action),
+						})
+				: undefined;
+			const result = await tool.execute(toolCallId, params, signal, wrappedUpdate, context);
+			return {
+				...result,
+				content: boundedContent(result.content),
+				details: projectLectorPresentation(tool.name, result.details, maxBytes, action),
+			};
+		},
+		renderResult(result, renderOptions, theme, context) {
+			const payload = parseLectorPresentation(result.details, tool.name);
+			if (payload === undefined && !renderOptions.isPartial && !context.isError) return fallbackText(result, theme);
+			if (!tool.renderResult) return fallbackText(result, theme);
+			// The envelope is the runtime validation boundary. Each existing domain renderer narrows
+			// its own payload variant; this is the single shared assertion that reconnects its generic.
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			const domainDetails = payload as TDetails;
+			return tool.renderResult({ ...result, details: domainDetails }, renderOptions, theme, context);
+		},
+	};
+}

package/extension/src/presentation/tool-presentation.ts

@@ -0,0 +1,171 @@
+export type PresentationFamily =
+	| "source"
+	| "markdown"
+	| "symbols"
+	| "locations"
+	| "diagnostics"
+	| "diff"
+	| "mutation"
+	| "status"
+	| "table"
+	| "tree"
+	| "candidates"
+	| "semantic-text";
+
+interface PresentationPathSpec {
+	readonly title: string;
+	readonly family: PresentationFamily;
+}
+
+interface ToolPresentationSpec extends PresentationPathSpec {
+	readonly actions?: Readonly<Record<string, PresentationPathSpec>>;
+}
+
+export const LECTOR_TOOL_PRESENTATION_SPECS: Readonly<Record<string, ToolPresentationSpec>> = {
+	read: { title: "Read File", family: "source" },
+	write: { title: "Write File", family: "mutation" },
+	edit: { title: "Edit File", family: "diff" },
+	find_symbols: { title: "Find Symbols", family: "symbols" },
+	localize_context: { title: "Localize Context", family: "candidates" },
+	go_to_definition: { title: "Go to Definition", family: "locations" },
+	go_to_implementation: { title: "Go to Implementation", family: "locations" },
+	find_references: { title: "Find References", family: "locations" },
+	hover: { title: "Hover", family: "markdown" },
+	document_symbols: { title: "Document Symbols", family: "tree" },
+	diagnostics: { title: "Diagnostics", family: "diagnostics" },
+	code_action_preview: { title: "Preview Code Actions", family: "candidates" },
+	code_action_apply: { title: "Apply Code Action", family: "mutation" },
+	diagnostic_delta: { title: "Diagnostic Delta", family: "diagnostics" },
+	call_hierarchy: {
+		title: "Call Hierarchy",
+		family: "tree",
+		actions: {
+			prepare: { title: "Prepare Call Hierarchy", family: "symbols" },
+			incoming: { title: "Incoming Calls", family: "tree" },
+			outgoing: { title: "Outgoing Calls", family: "tree" },
+		},
+	},
+	type_hierarchy: {
+		title: "Type Hierarchy",
+		family: "tree",
+		actions: {
+			prepare: { title: "Prepare Type Hierarchy", family: "symbols" },
+			supertypes: { title: "Supertypes", family: "tree" },
+			subtypes: { title: "Subtypes", family: "tree" },
+		},
+	},
+	impact_analysis: { title: "Impact Analysis", family: "tree" },
+	reference_based_rename: { title: "Rename File by References", family: "mutation" },
+	rename: {
+		title: "Rename Symbol",
+		family: "mutation",
+		actions: {
+			prepare: { title: "Prepare Rename", family: "semantic-text" },
+			apply: { title: "Rename Symbol", family: "mutation" },
+		},
+	},
+	symbol_annotations: {
+		title: "Symbol Annotations",
+		family: "semantic-text",
+		actions: {
+			create: { title: "Create Symbol Annotation", family: "mutation" },
+			get: { title: "Show Symbol Annotation", family: "markdown" },
+			list: { title: "List Symbol Annotations", family: "table" },
+			refresh: { title: "Refresh Symbol Annotation", family: "mutation" },
+			scrub: { title: "Scrub Symbol Annotation", family: "mutation" },
+			restore: { title: "Restore Symbol Annotation", family: "mutation" },
+			contain: { title: "Contain Symbol Annotation", family: "mutation" },
+			uncontain: { title: "Uncontain Symbol Annotation", family: "mutation" },
+			tree: { title: "Annotation Tree", family: "tree" },
+		},
+	},
+	reachable_from: { title: "Reachable Symbols", family: "tree" },
+	workspace_map: { title: "Workspace Map", family: "symbols" },
+	workspace_cache: {
+		title: "Workspace Cache",
+		family: "status",
+		actions: {
+			status: { title: "Workspace Cache Status", family: "status" },
+			populate: { title: "Populate Workspace Cache", family: "status" },
+			wait: { title: "Wait for Cache Job", family: "status" },
+			job_status: { title: "Cache Job Status", family: "status" },
+			release: { title: "Release Workspace", family: "mutation" },
+		},
+	},
+	git: {
+		title: "Git",
+		family: "semantic-text",
+		actions: {
+			status: { title: "Git Status", family: "status" },
+			log: { title: "Git Log", family: "table" },
+			diff: { title: "Git Diff", family: "diff" },
+			"compare-symbol": { title: "Compare Symbol", family: "diff" },
+			show: { title: "Show File at Git Ref", family: "source" },
+			"grep-ref": { title: "Search Git Ref", family: "locations" },
+			"grep-history": { title: "Search Git History", family: "locations" },
+			"ls-ref": { title: "List Files at Git Ref", family: "table" },
+			"is-ancestor": { title: "Check Git Ancestry", family: "semantic-text" },
+			"worktree-add": { title: "Create Git Worktree", family: "mutation" },
+			"worktree-remove": { title: "Remove Git Worktree", family: "mutation" },
+		},
+	},
+	search_code: { title: "Search Code", family: "locations" },
+	find_files: { title: "Find Files", family: "table" },
+	line_edit: { title: "Edit Lines", family: "diff" },
+	apply_patch: { title: "Apply Patch", family: "diff" },
+	mutation_history: {
+		title: "Mutation History",
+		family: "table",
+		actions: {
+			list: { title: "Mutation History", family: "table" },
+			revert: { title: "Revert Mutation", family: "mutation" },
+			"revert-transaction": { title: "Revert Transaction", family: "mutation" },
+		},
+	},
+	package_source: {
+		title: "Package Source",
+		family: "semantic-text",
+		actions: {
+			resolve: { title: "Resolve Package Source", family: "semantic-text" },
+			list: { title: "List Package Sources", family: "table" },
+			remove: { title: "Remove Package Source", family: "mutation" },
+			clean: { title: "Clean Package Sources", family: "mutation" },
+		},
+	},
+	repo_cache: {
+		title: "Repository Cache",
+		family: "semantic-text",
+		actions: {
+			fetch: { title: "Fetch Repository", family: "status" },
+			list: { title: "List Repository Cache", family: "table" },
+			evict: { title: "Evict Repository", family: "mutation" },
+		},
+	},
+	external_search: {
+		title: "External Search",
+		family: "candidates",
+		actions: {
+			github_repos: { title: "Search GitHub Repositories", family: "candidates" },
+			npm_packages: { title: "Search npm Packages", family: "candidates" },
+			sourcegraph_code: { title: "Search Public Code", family: "candidates" },
+		},
+	},
+	find_symbols_across_projects: { title: "Find Symbols Across Projects", family: "symbols" },
+	search_code_across_projects: { title: "Search Code Across Projects", family: "locations" },
+};
+
+export function presentationTitle(toolName: string, action?: string): string {
+	const spec = LECTOR_TOOL_PRESENTATION_SPECS[toolName];
+	if (!spec) throw new Error(`no presentation specification for ${toolName}`);
+	return (action ? spec.actions?.[action]?.title : undefined) ?? spec.title;
+}
+
+export function presentationFamily(toolName: string, action?: string): PresentationFamily {
+	const spec = LECTOR_TOOL_PRESENTATION_SPECS[toolName];
+	if (!spec) throw new Error(`no presentation specification for ${toolName}`);
+	return (action ? spec.actions?.[action]?.family : undefined) ?? spec.family;
+}
+
+export function presentationPathCount(): number {
+	return Object.values(LECTOR_TOOL_PRESENTATION_SPECS).reduce((count, spec) => count + (spec.actions ? Object.keys(spec.actions).length : 1), 0);
+}

package/extension/src/reference-based-rename/rendering.ts

@@ -0,0 +1,21 @@
+import type { OperationOutputs } from "@danypops/lector";
+import type { LectorTheme } from "../lector-tui-theme.ts";
+
+export type ReferenceBasedRenameOutcome = OperationOutputs["workspace.referenceBasedRename"];
+
+/** Formats a successful reference-based rename with every fact required for guarded transaction revert. */
+export function formatReferenceBasedRenameModelContent(outcome: ReferenceBasedRenameOutcome): string {
+	return [
+		`moved to ${outcome.movedTo}`,
+		outcome.filesUpdated.length === 0
+			? "no other files referenced it"
+			: `updated imports in ${outcome.filesUpdated.length} file(s): ${outcome.filesUpdated.join(", ")}`,
+		`transaction ${outcome.transactionId}`,
+		...outcome.caveats.map((caveat) => `caveat: ${caveat}`),
+	].join("\n");
+}
+
+/** Formats the compact human mutation result while preserving its reusable transaction identity. */
+export function formatReferenceBasedRenameResult(outcome: ReferenceBasedRenameOutcome, theme: LectorTheme): string {
+	return `${theme.fg("success", "moved")} ${theme.fg("accent", outcome.movedTo)} ${theme.fg("dim", `(${outcome.filesUpdated.length} import(s) updated, transaction ${outcome.transactionId})`)}`;
+}

package/extension/src/repo-cache/rendering.ts

@@ -2,6 +2,7 @@ import type { CachedRepositoryEntry, CachedRepositoryPage, RepoFetchResult } fro
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import type { TableColumn } from "malevich-tui-components";
 import type { LectorTheme } from "../lector-tui-theme.ts";
+import { presentationTitle } from "../presentation/tool-presentation.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;
@@ -17,16 +18,16 @@ export function formatRepoCacheCall(
 	args: { owner?: unknown; repo?: unknown; ref?: unknown; host?: unknown; text?: unknown },
 	theme: LectorTheme,
 ): string {
-	const label = theme.fg("toolTitle", theme.bold("repo_cache"));
+	const label = theme.fg("toolTitle", theme.bold(presentationTitle("repo_cache", action)));
 	if (action === "list") {
 		const filter = typeof args.text === "string" && args.text.length > 0 ? args.text : typeof args.repo === "string" ? args.repo : "";
-		return `${label} ${theme.fg("accent", "list")}${filter ? ` ${theme.fg("dim", filter)}` : ""}`;
+		return `${label}${filter ? ` ${theme.fg("accent", filter)}` : ""}`;
 	}
 	const host = typeof args.host === "string" && args.host.length > 0 ? args.host : "github.com";
 	const owner = typeof args.owner === "string" ? args.owner : "";
 	const repo = typeof args.repo === "string" ? args.repo : "";
 	const ref = typeof args.ref === "string" ? `@${args.ref}` : "";
-	return `${label} ${theme.fg("accent", action)} ${theme.fg("dim", `${host}/${owner}/${repo}${ref}`)}`;
+	return `${label} ${theme.fg("accent", `${host}/${owner}/${repo}${ref}`)}`;
 }
 
 export function formatRepoFetchResult(result: (RepoFetchResult & { workspaceId: string }) | undefined, theme: LectorTheme): string {

package/extension/src/search/rendering.ts

@@ -2,13 +2,14 @@ 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 { presentationTitle } from "../presentation/tool-presentation.ts";
 
 const DEFAULT_VISIBLE_MATCHES = 20;
 
 export function formatSearchCall(args: { directory?: unknown; query?: unknown }, theme: LectorTheme): string {
 	const directory = typeof args.directory === "string" ? args.directory : "";
 	const query = typeof args.query === "string" ? args.query : "";
-	return `${theme.fg("toolTitle", theme.bold("search_code"))} ${theme.fg("accent", `"${query}"`)} ${theme.fg("dim", directory)}`;
+	return `${theme.fg("toolTitle", theme.bold(presentationTitle("search_code")))} ${theme.fg("accent", `"${query}"`)} ${theme.fg("dim", directory)}`;
 }
 
 export function formatSearchResult(result: TextSearchResult | undefined, expanded: boolean, theme: LectorTheme): string {

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

@@ -1,13 +1,15 @@
 import {
 	type CacheResultCounts,
 	type JobSnapshot,
+	type OperationOutputs,
 	type PopulateSymbolGraphResult,
 	remoteErrorIs,
 	resolveLectorDaemonConnection,
 	type WorkspaceCacheStatus,
 } from "@danypops/lector";
 import { connectPushChannel } from "@danypops/vehicle-client/daemon-client";
-import { lectorClient, withWorkspace, workspaceForProjectDirectory } from "../lector-client.ts";
+import { forgetWorkspaceId, lectorClient, withWorkspace, workspaceForProjectDirectory } from "../lector-client.ts";
+import { invokeLectorVehicleOperation, type LectorVehicleCall } from "../vehicle-client.ts";
 
 export interface JobWatchHandle {
 	close(): void;
@@ -25,9 +27,11 @@ export type JobWatchOutcome = { readonly status: "subscribed"; readonly handle:
  * want today's exact contract.
  */
 const DEFAULT_POPULATE_RETRY_TIME_BUDGET_MS = 60_000;
+const WORKSPACE_RELEASE_PERMISSIONS = ["workspace:write"];
 
 export interface WorkspaceCacheOperations {
 	status(directory: string, maxFiles: number, maxSymbolsPerFile: number): Promise<WorkspaceCacheStatus>;
+	release(directory: string, call: LectorVehicleCall): Promise<OperationOutputs["workspace.release"]>;
 	submit(
 		directory: string,
 		maxFiles: number,
@@ -39,6 +43,8 @@ export interface WorkspaceCacheOperations {
 	watchJob?(jobId: string, onJob: (job: JobSnapshot<PopulateSymbolGraphResult>) => void): Promise<JobWatchOutcome>;
 }
 
+export type WorkspaceCacheMonitorOperations = Omit<WorkspaceCacheOperations, "release">;
+
 export function createWorkspaceCacheOperations(ownerId?: string): WorkspaceCacheOperations {
 	return {
 		status(directory, maxFiles, maxSymbolsPerFile) {
@@ -50,6 +56,21 @@ export function createWorkspaceCacheOperations(ownerId?: string): WorkspaceCache
 				},
 			);
 		},
+		release(directory, call) {
+			return withWorkspace(
+				() => workspaceForProjectDirectory(directory),
+				async ({ workspaceId, root }) => {
+					const result = await invokeLectorVehicleOperation<OperationOutputs["workspace.release"]>(
+						"workspace.release",
+						{ workspaceId },
+						WORKSPACE_RELEASE_PERMISSIONS,
+						call,
+					);
+					forgetWorkspaceId(root);
+					return result;
+				},
+			);
+		},
 		submit(directory, maxFiles, maxSymbolsPerFile, waitMs = 0, retryTimeBudgetMs = DEFAULT_POPULATE_RETRY_TIME_BUDGET_MS) {
 			return withWorkspace(
 				() => workspaceForProjectDirectory(directory),
@@ -159,7 +180,7 @@ export type JobCompletionOutcome =
 
 /** Waits on Vehicle push delivery and checks status on a bounded cadence when push is unavailable or disconnected. */
 export async function waitForJobCompletion(
-	operations: WorkspaceCacheOperations,
+	operations: WorkspaceCacheMonitorOperations,
 	jobId: string,
 	options: WaitForJobCompletionOptions,
 ): Promise<JobCompletionOutcome> {
@@ -205,7 +226,7 @@ export async function waitForJobCompletion(
 }
 
 /** Drives one bounded session cache lifecycle; Pi event handlers only render its states. */
-export async function monitorWorkspaceCache(operations: WorkspaceCacheOperations, options: MonitorWorkspaceCacheOptions): Promise<void> {
+export async function monitorWorkspaceCache(operations: WorkspaceCacheMonitorOperations, options: MonitorWorkspaceCacheOptions): Promise<void> {
 	const sleep = options.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
 	const initial = await operations.status(options.directory, options.maxFiles, options.maxSymbolsPerFile);
 	if (!options.shouldContinue()) return;

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

@@ -1,17 +1,18 @@
-import type { CacheResultCounts, JobSnapshot, PopulateSymbolGraphResult, WorkspaceCacheStatus } from "@danypops/lector";
+import type { CacheResultCounts, JobSnapshot, OperationOutputs, PopulateSymbolGraphResult, WorkspaceCacheStatus } from "@danypops/lector";
 import type { LectorTheme } from "../lector-tui-theme.ts";
+import { presentationTitle } from "../presentation/tool-presentation.ts";
 
-type WorkspaceCacheAction = "status" | "populate" | "wait" | "job_status";
+type WorkspaceCacheAction = "status" | "populate" | "wait" | "job_status" | "release";
 
 export function formatWorkspaceCacheCall(
 	action: WorkspaceCacheAction,
 	args: { directory?: unknown; maxFiles?: unknown; maxSymbolsPerFile?: unknown; jobId?: unknown },
 	theme: LectorTheme,
 ): string {
-	const label = theme.fg("toolTitle", theme.bold("workspace_cache"));
+	const label = theme.fg("toolTitle", theme.bold(presentationTitle("workspace_cache", action)));
 	if (action === "job_status" || action === "wait") {
 		const jobId = typeof args.jobId === "string" ? args.jobId : "";
-		return `${label} ${theme.fg("accent", action)} ${theme.fg("dim", jobId)}`;
+		return `${label} ${theme.fg("accent", jobId)}`;
 	}
 	const directory = typeof args.directory === "string" ? args.directory : "";
 	const maxFiles = typeof args.maxFiles === "number" ? String(args.maxFiles) : "default";
@@ -20,7 +21,7 @@ export function formatWorkspaceCacheCall(
 		action === "populate" && (typeof args.maxFiles === "number" || typeof args.maxSymbolsPerFile === "number")
 			? theme.fg("dim", ` (maxFiles=${maxFiles}, maxSymbolsPerFile=${maxSymbolsPerFile})`)
 			: "";
-	return `${label} ${theme.fg("accent", action)} ${theme.fg("dim", directory)}${bounds}`;
+	return `${label} ${theme.fg("accent", directory)}${bounds}`;
 }
 
 function formatResultCounts(result: CacheResultCounts): string {
@@ -28,6 +29,23 @@ function formatResultCounts(result: CacheResultCounts): string {
 	return `${result.filesProcessed}/${result.filesAttempted} files${failed}, ${result.symbolsProcessed} symbols, ${result.nodesAdded} nodes, ${result.edgesAdded} edges`;
 }
 
+export function formatWorkspaceReleaseModelContent(outcome: OperationOutputs["workspace.release"]): string {
+	return [
+		`released workspace ${outcome.workspaceId}`,
+		`closed indexes: ${outcome.closedIndexes}`,
+		`closed graph: ${outcome.closedGraph}`,
+		`closed watch: ${outcome.closedWatch}`,
+	].join("\n");
+}
+
+export function formatWorkspaceReleaseResult(outcome: OperationOutputs["workspace.release"] | undefined, theme: LectorTheme): string {
+	if (!outcome) return theme.fg("dim", "No result.");
+	return theme.fg(
+		"success",
+		`released ${outcome.workspaceId} -- ${outcome.closedIndexes} index(es), graph ${outcome.closedGraph ? "closed" : "idle"}, watch ${outcome.closedWatch ? "closed" : "idle"}`,
+	);
+}
+
 export function formatWorkspaceCacheStatusResult(status: WorkspaceCacheStatus | undefined, theme: LectorTheme): string {
 	if (!status) return theme.fg("dim", "No result.");
 	if (status.status === "not-cached") return theme.fg("warning", `not cached (${status.reason})`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.13.11",
+	"version": "0.15.0",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -22,7 +22,7 @@
 		"@danypops/vehicle-client-pi": "^0.45.0"
 	},
 	"dependencies": {
-		"@danypops/lector": "^0.20.4",
+		"@danypops/lector": "^0.21.0",
 		"@danypops/vehicle-client": "^0.10.8",
 		"@danypops/vehicle-core": "^0.19.1",
 		"malevich-tui-components": "^0.32.1",